553 lines
19 KiB
Markdown
553 lines
19 KiB
Markdown
AVAP TM Dev Studio 2024 lets you perform most tasks directly
|
|
from the keyboard. This page lists out the default bindings (keyboard
|
|
shortcuts) and describes how you can update them.
|
|
|
|
### Keyboard Shortcuts editor
|
|
|
|
AVAP TM Dev Studio provides a rich and easy keyboard shortcuts
|
|
editing experience using Keyboard Shortcuts editor. It
|
|
lists all available commands with and without keybindings and you can
|
|
easily change / remove / reset their keybindings using the available
|
|
actions. It also has a search box on the top that helps you in finding
|
|
commands or keybindings. You can open this editor by going to the menu
|
|
under File > Preferences >{' '}
|
|
Keyboard Shortcuts .
|
|
|
|
Most importantly, you can see keybindings according to your keyboard
|
|
layout. For example, key binding `Cmd+\` in US keyboard layout
|
|
will be shown as `Ctrl+Shift+Alt+Cmd+7` when layout is changed
|
|
to German. The dialog to enter key binding will assign the correct and
|
|
desired key binding as per your keyboard layout.
|
|
|
|
For doing more advanced keyboard shortcut customization, read Advanced
|
|
Customization.
|
|
|
|
### Keymap extensions
|
|
|
|
Keyboard shortcuts are vital to productivity and changing keyboarding
|
|
habits can be tough. To help with this, File >{' '}
|
|
Preferences >{' '}
|
|
Migrate Keyboard Shortcuts from... shows you a list of
|
|
popular keymap extensions. These extensions modify the AVAP TM {' '}
|
|
Dev Studio shortcuts to match those of other editors so you don't need
|
|
to learn new keyboard shortcuts. There is also a Keymaps category of
|
|
extensions in the Marketplace.
|
|
|
|
### Keyboard Shortcuts Reference
|
|
|
|
We also have a printable version of these keyboard shortcuts.{' '}
|
|
Help > Keyboard Shortcut Reference {' '}
|
|
displays a condensed PDF version suitable for printing as an easy
|
|
reference.
|
|
|
|
Below are links to the three platform-specific versions (US English
|
|
keyboard):
|
|
|
|
* Windows
|
|
* macOS
|
|
* Linux
|
|
|
|
### Detecting keybinding conflicts
|
|
|
|
If you have many extensions installed or you have customized your keyboard
|
|
shortcuts, you can sometimes have keybinding conflicts where the same
|
|
keyboard shortcut is mapped to several commands. This can result in
|
|
confusing behavior, especially if different keybindings are going in and
|
|
out of scope as you move around the editor.
|
|
|
|
The Keyboard Shortcuts editor has a context menu command{' '}
|
|
Show Same Keybindings , which will filter the keybindings
|
|
based on a keyboard shortcut to display conflicts.
|
|
|
|
Pick a command with the keybinding you think is overloaded and you can see
|
|
if multiple commands are defined, the source of the keybindings and when
|
|
they are active.
|
|
|
|
### Troubleshooting keybindings
|
|
|
|
To troubleshoot keybindings problems, you can execute the command{' '}
|
|
Developer: Toggle Keyboard Shortcuts Troubleshooting .
|
|
This will activate logging of dispatched keyboard shortcuts and will open
|
|
an output panel with the corresponding log file.
|
|
|
|
You can then press your desired keybinding and check what keyboard
|
|
shortcut AVAP™ DS detects and what command is invoked.
|
|
|
|
For example, when pressing `cmd+/` in a code editor on macOS,
|
|
the logging output would be:
|
|
|
|
```javascript
|
|
[KeybindingService]: / Received keydown event - modifiers: [meta], code:
|
|
MetaLeft, keyCode: 91, key: Meta
|
|
|
|
[KeybindingService]: | Converted keydown event - modifiers: [meta],
|
|
code: MetaLeft, keyCode: 57 ('Meta')
|
|
|
|
[KeybindingService]: \ Keyboard event cannot be dispatched.
|
|
|
|
[KeybindingService]: / Received keydown event - modifiers: [meta], code:
|
|
Slash, keyCode: 191, key: /
|
|
[KeybindingService]: | Converted keydown event - modifiers: [meta],
|
|
code: Slash, keyCode: 85 ('/')
|
|
|
|
[KeybindingService]: | Resolving meta+[Slash]
|
|
|
|
[KeybindingService]: \ From 2 keybinding entries, matched
|
|
editor.action.commentLine, when: editorTextFocus &&
|
|
!editorReadonly, source: built-in.
|
|
```
|
|
|
|
The first keydown event is for the MetaLeft key (cmd) and cannot
|
|
be dispatched. The second keydown event is for the Slash key (/)
|
|
and is dispatched as meta+[Slash]. There were two keybinding entries
|
|
mapped from meta+[Slash] and the one that matched was for the command
|
|
editor.action.commentLine, which has the when condition editorTextFocus
|
|
&& !editorReadonly and is a built-in keybinding entry.
|
|
|
|
### Viewing modified keybindings
|
|
|
|
You can view any user modified keyboard shortcuts in AVAP TM Dev
|
|
Studio in the Keyboard Shortcuts editor with the Show
|
|
User Keybindings command in the More Actions (...) menu. This
|
|
applies the @source:user filter to the Keyboard Shortcuts editor
|
|
(Source is 'User').
|
|
|
|
### Advanced customization
|
|
|
|
All keyboard shortcuts in AVAP TM Dev Studio can be customized
|
|
via the keybindings.json file.
|
|
|
|
To configure keyboard shortcuts through the JSON file, open{' '}
|
|
Keyboard Shortcuts editor and select the{' '}
|
|
Open Keyboard Shortcuts (JSON) button on the
|
|
right of the editor title bar. This will open your keybindings.json file
|
|
where you can overwrite the Default Keyboard Shortcuts.
|
|
|
|
You can also open the keybindings.json file from the Command Palette
|
|
(Ctrl+Shift+P) with the Preferences: Open Keyboard Shortcuts
|
|
(JSON) command.
|
|
|
|
### Keyboard rules
|
|
|
|
Each rule consists of:
|
|
|
|
* a key that describes the pressed keys.
|
|
* a command containing the identifier of the command to execute.
|
|
* an optional when clause containing a boolean expression that will be evaluated depending on the current context.
|
|
|
|
Chords (two separate keypress actions) are described by separating
|
|
the two keypresses with a space. For example, `Ctrl+K Ctrl+C` .
|
|
|
|
When a key is pressed:
|
|
|
|
* the rules are evaluated from bottom to{' '} top .
|
|
* the first rule that matches, both the key and in terms of when, is accepted.
|
|
* no more rules are processed.
|
|
* if a rule is found and has a command set, the command is executed.
|
|
|
|
The additional keybindings.json rules are appended at runtime to the
|
|
bottom of the default rules, thus allowing them to overwrite the default
|
|
rules. The keybindings.json file is watched by AVAP™ DS so editing it
|
|
while AVAP TM Dev Studio is running will update the rules at
|
|
runtime.
|
|
|
|
The keyboard shortcuts dispatching is done by analyzing a list of rules
|
|
that are expressed in JSON. Here are some examples:
|
|
|
|
```javascript
|
|
// Keybindings that are active when the focus is in the editor
|
|
|
|
{ "key": "home", "command": "cursorHome", "when": "editorTextFocus"
|
|
},
|
|
|
|
{ "key": "shift+home", "command": "cursorHomeSelect", "when":
|
|
"editorTextFocus" },
|
|
|
|
|
|
// Keybindings that are complementary
|
|
|
|
{ "key": "f5", "command": "workbench.action.debug.continue",
|
|
"when": "inDebugMode" },
|
|
|
|
{ "key": "f5", "command": "workbench.action.debug.start", "when":
|
|
"!inDebugMode" },
|
|
|
|
|
|
// Global keybindings
|
|
|
|
{ "key": "ctrl+f", "command": "actions.find" },
|
|
|
|
{ "key": "alt+left", "command": "workbench.action.navigateBack"
|
|
},
|
|
|
|
{ "key": "alt+right", "command": "workbench.action.navigateForward"
|
|
},
|
|
|
|
|
|
// Global keybindings using chords (two separate keypress
|
|
actions)
|
|
|
|
{ "key": "ctrl+k enter", "command": "workbench.action.keepEditor"
|
|
},
|
|
|
|
{ "key": "ctrl+k ctrl+w", "command":
|
|
"workbench.action.closeAllEditors" },
|
|
```
|
|
|
|
### Accepted keys
|
|
|
|
The key is made up of modifiers and the key itself.
|
|
|
|
The following modifiers are accepted:
|
|
|
|
The following keys are accepted:
|
|
|
|
* `f1-f19` , `a-z` , `0-9`
|
|
* ```, `-` , `=` , `[` , `]` ,{' '} `\` , `;` , `'` , `,` ,{' '} `.` , `/`
|
|
* `left` , `up` , `right` ,{' '} `down` , `pageup` , `pagedown` ,{' '} `end` , `home`
|
|
* `tab` , `enter` , `escape` ,{' '} `space` , `backspace` , `delete`
|
|
* `pausebreak` , `capslock` , `insert`
|
|
* `numpad0-numpad9` , `numpad_multiply` ,{' '} `numpad_add` , `numpad_separator`
|
|
* `numpad_subtract` , `numpad_decimal` ,{' '} `numpad_divide`
|
|
|
|
### Command arguments
|
|
|
|
You can invoke a command with arguments. This is useful if you often
|
|
perform the same operation on a specific file or folder. You can add a
|
|
custom keyboard shortcut to do exactly what you want.
|
|
|
|
The following is an example overriding the `Enter` key to print
|
|
some text:
|
|
|
|
```javascript
|
|
{
|
|
"key": "enter",
|
|
"command": "type",
|
|
"args": { "text": "Hello World" },
|
|
"when": "editorTextFocus"
|
|
|
|
}
|
|
```
|
|
|
|
The type command will receive {"text": "Hello
|
|
World"} as its first argument and add "Hello World" to
|
|
the file instead of producing the default command.
|
|
|
|
For more information on commands that take arguments, refer to Built-in
|
|
Commands.
|
|
|
|
### Running multiple commands
|
|
|
|
It is possible to create a keybinding that runs several other commands
|
|
sequentially using the command runCommands.
|
|
|
|
Run several commands without arguments: copy current line down, mark the
|
|
current line as comment, move cursor to copied line
|
|
|
|
```javascript
|
|
{
|
|
"key": "ctrl+alt+c",
|
|
"command": "runCommands",
|
|
"args": {
|
|
"commands": [ "editor.action.copyLinesDownAction",
|
|
"cursorUp",
|
|
"editor.action.addCommentLine",
|
|
"cursorDown"
|
|
] }
|
|
|
|
},
|
|
```
|
|
|
|
It is also possible to pass arguments to commands: create a new untitled
|
|
TypeScript file and insert a custom snippet
|
|
|
|
```javascript
|
|
{
|
|
"key": "ctrl+n",
|
|
"command": "runCommands",
|
|
"args": {
|
|
"commands": [ {
|
|
"command": "workbench.action.files.newUntitledFile",
|
|
"args": {
|
|
"languageId": "typescript"
|
|
}
|
|
},
|
|
{
|
|
"command": "editor.action.insertSnippet",
|
|
"args": {
|
|
"langId": "typescript",
|
|
"snippet": "class ${1:ClassName}
|
|
{\n\tconstructor() {\n\t\t$0\n\t}\n}"
|
|
}
|
|
}
|
|
] }
|
|
|
|
},
|
|
```
|
|
|
|
Note that commands run by runCommands receive the value of
|
|
"args" as the first argument. So in the example above,
|
|
workbench.action.files.newUntitledFile receives
|
|
{"languageId": "typescript" } as its first
|
|
and only argument.
|
|
|
|
To pass several arguments, one needs to have "args" as an array:
|
|
|
|
```javascript
|
|
{
|
|
"key": "ctrl+shift+e",
|
|
"command": "runCommands",
|
|
"args": {
|
|
"commands": [ {
|
|
// command invoked with 2 arguments:
|
|
vscode.executeCommand("myCommand", "arg1", "arg2")
|
|
"command": "myCommand",
|
|
"args": ["arg1", "arg2"]
|
|
}
|
|
] }
|
|
|
|
}
|
|
```
|
|
|
|
To pass an array as the first argument, one needs to wrap the array in
|
|
another array: "args": [ [1, 2, 3] ].
|
|
|
|
### Removing a specific key binding rule
|
|
|
|
You can write a key binding rule that targets the removal of a specific
|
|
default key binding. With the keybindings.json, it was always possible to
|
|
redefine all the key bindings of AVAP TM Dev Studio, but it can
|
|
be difficult to make a small tweak, especially around overloaded keys,
|
|
such as `Tab` or `Escape` . To remove a specific key
|
|
binding, add a - to the command and the rule will be a removal rule.
|
|
|
|
Here is an example:
|
|
|
|
```javascript
|
|
// In Default Keyboard Shortcuts
|
|
|
|
...
|
|
|
|
{ "key": "tab", "command": "tab", "when": ... },
|
|
|
|
{ "key": "tab", "command": "jumpToNextSnippetPlaceholder", "when":
|
|
... },
|
|
|
|
{ "key": "tab", "command": "acceptSelectedSuggestion", "when": ...
|
|
},
|
|
|
|
...
|
|
|
|
|
|
// To remove the second rule, for example, add in keybindings.json:
|
|
|
|
{ "key": "tab", "command": "-jumpToNextSnippetPlaceholder" }
|
|
```
|
|
|
|
To override a specific key binding rule with an empty action, you can
|
|
specify an empty command:
|
|
|
|
```javascript
|
|
// To override and disable any `tab` keybinding, for example, add in
|
|
keybindings.json:
|
|
|
|
{ "key": "tab", "command": "" }
|
|
```
|
|
|
|
### Keyboard layouts
|
|
|
|
The keys above are string representations for virtual keys and do not
|
|
necessarily relate to the produced character when they are pressed. More
|
|
precisely:
|
|
|
|
* Reference: Virtual-Key Codes (Windows)
|
|
* `tab` for VK_TAB (0x09)
|
|
* ; for VK_OEM_1 (0xBA)
|
|
* `=` for VK_OEM_PLUS (0xBB)
|
|
* `,` for VK_OEM_COMMA (0xBC)
|
|
* `-` for VK_OEM_MINUS (0xBD)
|
|
* `.` for VK_OEM_PERIOD (0xBE)
|
|
* `/` for VK_OEM_2 (0xBF)
|
|
* ` for VK_OEM_3 (0xC0)
|
|
* `[` for VK_OEM_4 (0xDB)
|
|
* `\` for VK_OEM_5 (0xDC)
|
|
* `]` for VK_OEM_6 (0xDD)
|
|
* `'` for VK_OEM_7 (0xDE)
|
|
* etc.
|
|
|
|
Different keyboard layouts usually reposition the above virtual keys or
|
|
change the characters produced when they are pressed. When using a
|
|
different keyboard layout than the standard US, AVAP TM Dev
|
|
Studio does the following:
|
|
|
|
All the key bindings are rendered in the UI using the current system's
|
|
keyboard layout. For example, Split Editor when using a French
|
|
(France) keyboard layout is now rendered as `Ctrl+*` :
|
|
|
|
When editing keybindings.json, AVAP TM Dev Studio highlights
|
|
misleading key bindings, those that are represented in the file with the
|
|
character produced under the standard US keyboard layout, but that need
|
|
pressing keys with different labels under the current system's
|
|
keyboard layout. For example, here is how the{' '}
|
|
Default Keyboard Shortcuts rules look like when using a
|
|
French (France) keyboard layout:
|
|
|
|
There is also a widget that helps input the key binding rule when editing
|
|
keybindings.json. To launch the Define Keybinding widget, press{' '}
|
|
`Ctrl+K Ctrl+K` . The widget listens for key presses and renders
|
|
the serialized JSON representation in the text box and below it, the keys
|
|
that AVAP TM Dev Studio has detected under your current keyboard
|
|
layout. Once you've typed the key combination you want, you can press{' '}
|
|
`Enter` and a rule snippet will be inserted.
|
|
|
|
### Keyboard layout-independent bindings
|
|
|
|
Using scan codes, it is possible to define keybindings which do not change
|
|
with the change of the keyboard layout. For example:
|
|
|
|
```javascript
|
|
{ "key": "cmd+[Slash]", "command": "editor.action.commentLine",
|
|
"when": "editorTextFocus" }
|
|
```
|
|
|
|
Accepted scan codes:
|
|
|
|
* `[F1]-[F19]` , `[KeyA]-[KeyZ]` ,{' '} `[Digit0]-[Digit9]`
|
|
* `[Backquote]` , `[Minus]` , `[Equal]` ,{' '} `[BracketLeft]` , `[BracketRight]` ,{' '} `[Backslash]` , `[Semicolon]` ,{' '} `[Quote]` , `[Comma]` , `[Period]` ,{' '} `[Slash]`
|
|
* `[ArrowLeft]` , `[ArrowUp]` ,{' '} `[ArrowRight]` , `[ArrowDown]` ,{' '} `[PageUp]` , `[PageDown]` , `[End]` ,{' '} `[Home]`
|
|
* `[Tab]` , `[Enter]` , `[Escape]` ,{' '} `[Space]` , `[Backspace]` , `[Delete]`
|
|
* `[Pause]` , `[CapsLock]` , `[Insert]`
|
|
* `[Numpad0]-[Numpad9]` , `[NumpadMultiply]` ,{' '} `[NumpadAdd]` , `[NumpadComma]`
|
|
* `[NumpadSubtract]` , `[NumpadDecimal]` ,{' '} `[NumpadDivide]`
|
|
|
|
### when clause contexts
|
|
|
|
AVAP TM Dev Studio gives you fine control over when your key
|
|
bindings are enabled through the optional when clause. If your key binding
|
|
doesn't have a when clause, the key binding is globally available at
|
|
all times. A when clause evaluates to either Boolean true or false for
|
|
enabling key bindings.
|
|
|
|
AVAP TM Dev Studio sets various context keys and specific values
|
|
depending on what elements are visible and active in the AVAP TM {' '}
|
|
Dev Studio UI. For example, the built-in Start Debugging command has the
|
|
keyboard shortcut `F5` , which is only enabled when there is an
|
|
appropriate debugger available (context debuggersAvailable is
|
|
true) and the editor isn't in debug mode (context inDebugMode
|
|
is false):
|
|
|
|
You can also view a keybinding's when clause directly in the Default
|
|
Keybindings JSON (
|
|
|
|
Preferences: Open Default Keyboard Shortcuts (JSON)
|
|
|
|
):
|
|
|
|
```javascript
|
|
{ "key": "f5", "command": "workbench.action.debug.start",
|
|
"when": "debuggersAvailable && !inDebugMode" },
|
|
```
|
|
|
|
For when clause conditional expressions, the following conditional
|
|
operators are useful for keybindings:
|
|
|
|
You can find the full list of when clause conditional operators in the
|
|
when clause contexts reference.
|
|
|
|
You can find some of the available when clause contexts in the when clause
|
|
context reference.
|
|
|
|
The list there isn't exhaustive and you can find other when clause
|
|
contexts by searching and filtering in the Keyboard Shortcuts editor (
|
|
Preferences: Open Keyboard Shortcuts ) or reviewing
|
|
the Default Keybindings JSON file (
|
|
|
|
Preferences: Open Default Keyboard Shortcuts (JSON)
|
|
|
|
).
|
|
|
|
### Custom keybindings for refactorings
|
|
|
|
The editor.action.codeAction command lets you configure keybindings for
|
|
specific Refactorings (Code Actions). For example, the keybinding
|
|
below triggers the Extract function refactoring Code
|
|
Actions:
|
|
|
|
```javascript
|
|
{
|
|
"key": "ctrl+shift+r ctrl+e",
|
|
"command": "editor.action.codeAction",
|
|
"args": {
|
|
"kind": "refactor.extract.function"
|
|
}
|
|
|
|
}
|
|
```
|
|
|
|
This is covered in depth in the Refactoring topic where you can learn
|
|
about different kinds of Code Actions and how to prioritize them in the
|
|
case of multiple possible refactorings.
|
|
|
|
### Default Keyboard Shortcuts
|
|
|
|
You can view all default keyboard shortcuts in AVAP Dev Studio in the{' '}
|
|
Keyboard Shortcuts editor with the{' '}
|
|
Show Default Keybindings command in the{' '}
|
|
More Actions (...) menu. This applies the
|
|
@source:default filter to the Keyboard Shortcuts editor
|
|
( Source is 'Default').
|
|
|
|
You can view the default keyboard shortcuts as a JSON file using the
|
|
command{' '}
|
|
|
|
Preferences: Open Default Keyboard Shortcuts (JSON)
|
|
|
|
.
|
|
|
|
Some commands included below do not have default keyboard shortcuts and so
|
|
are displayed as unassigned but you can assign your own keybindings.
|
|
|
|
### Next steps
|
|
|
|
Now that you know about our Key binding support, what's next...
|
|
|
|
* Language Support - Our Good, Better, Best language grid to see what you can expect
|
|
* Debugging - This is where AVAP™ DS really shines
|
|
* Node.js - End to end Node.js scenario with a sample app
|
|
|
|
### Common questions
|
|
|
|
In the Keyboard Shortcut editor, you can filter on
|
|
specific keystrokes to see which commands are bound to which keys. Below
|
|
you can see that Ctrl+Shift+P is bound to{' '}
|
|
Show All Commands to bring up the Command Palette.
|
|
|
|
Find a rule that triggers the action in the{' '}
|
|
Default Keyboard Shortcuts and write a modified version
|
|
of it in your keybindings.json file:
|
|
|
|
```javascript
|
|
// Original, in Default Keyboard Shortcuts
|
|
|
|
{ "key": "ctrl+shift+k", "command": "editor.action.deleteLines",
|
|
"when": "editorTextFocus" },
|
|
|
|
// Modified, in User/keybindings.json, Ctrl+D now will also trigger this
|
|
action
|
|
|
|
{ "key": "ctrl+d", "command": "editor.action.deleteLines",
|
|
"when": "editorTextFocus" },
|
|
```
|
|
|
|
Use the editorLangId context key in your when clause:
|
|
|
|
```javascript
|
|
{ "key": "shift+alt+a", "command": "editor.action.blockComment",
|
|
"when": "editorTextFocus && editorLangId == csharp"
|
|
},
|
|
```
|
|
|
|
The most common problem is a syntax error in the file. Otherwise, try
|
|
removing the when clause or picking a different key. Unfortunately, at
|
|
this point, it is a trial and error process.
|