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.
