I'm trying to have the same command for multiple actions on vscode like run/stop on .py, same on a notebook, but when I add the cmd+enter keybind for one shortcut, the other stops working. I found it pretty random, sometimes it works sometimes not, yesterday it worked and I just opened my project, didn't work...
I've checked the JSON files Default Keyboard Shortcuts (JSON) and Keyboard Shortcuts (JSON) but everything seems to be fine.
Anyone that went through a similar experience or has a fix?
Secondary shortcut may not work because in the json file Keyboard Shortcuts (JSON), when setting a new shortcut, you have a condition where.
This file is the user keybind file and will store all the shortcuts you set or remove. For the removed ones (the default that you change), they have a minus in front of the command name.
To set a new shortcut you need to specify the when.
{
"key": "cmd+enter",
"command": "workbench.action.debug.stop",
"when": "!notebookEditorFocused && inDebugMode"
},
{
"key": "shift+f5",
"command": "-workbench.action.debug.stop",
"when": "inDebugMode && !focusedSessionIsAttach"
}
When I step through the the VSCode Quick Open menu, I want it not to automatically switch between editors until I've selected the file I'm interested in (and hit enter). But with a recent (April?) change to VSCode, it automatically shows me each file as I step through the menu. How can I disable that behavior?
Here's my motivation, for those who are interested:
One of the (common?) ways to use VSCode's "Quick Open" menu is to use it like the "last channel" button on a TV remote. I want to open one editor, then open another, and then quickly toggle back and forth between the two. Since they are my current and most-recent editors, they should appear at the top of the Quick Open Menu, so toggling between them is fast.
This used to work just fine, but a recent (April?) change to the Quick Open menu seems to have broken this functionality. Now, it automatically activates the editor for every file that I step through in the menu, changing my "most recent" ordering. It can no longer be used like a "last channel" button.
Here's a short video demonstrating the problem. Here, I'm starting with one.txt. I want to select five.txt via the Quick Open menu, and then quickly toggle between the two. But it opens all the other files along the way!
(In fact, if you watch closely, the behavior is even weirder: It doesn't show me the currently selected file -- it opens the editor for each file as it becomes UN-selected. Maybe this is just a bug?)
FWIW, here are the the relevant parts of my keybindings.json, to make it clear which commands I'm referring to:
// keybindings.json
[
// Trigger quick open menu and pre-select the previously used editor.
// (With either cmd+left/cmd+right)
{
"key": "cmd+left",
"command": "workbench.action.quickOpenPreviousRecentlyUsedEditorInGroup",
"when": "!inEditorsPicker"
},
{
"key": "cmd+right",
"command": "workbench.action.quickOpenPreviousRecentlyUsedEditorInGroup",
"when": "!inEditorsPicker"
},
// Once the menu is open, scan through the choices.
// (Forward with cmd+right, backward with cmd+left)
{
"key": "cmd+left",
"command": "workbench.action.quickOpenNavigatePreviousInEditorPicker",
"when": "inEditorsPicker && inQuickOpen"
},
{
"key": "cmd+right",
"command": "workbench.action.quickOpenNavigateNextInEditorPicker",
"when": "inEditorsPicker && inQuickOpen"
}
]
The issue is that my chosen key binding conflicts with a hard-coded key binding in VSCode. A workaround is to just use a key other than the right arrow.
Explanation here: https://github.com/microsoft/vscode/issues/98479#issuecomment-633378132
VSCode by default binds cmd+p to workbench.action.quickOpen. Which is fine. My only issue is that when you confirm a quickOpen on a file using enter it opens the file in a “preview” mode (indicated by the tab’s name having an italic font). This “preview” mode means that if I open two files in a row using cmd+p the action of opening the second will take over the “preview” slot, effectively closing the first file's preview.
VSCode has a setting called workbench.editor.enablePreviewFromQuickOpen which you can use to change this behavior globally. But I don’t want to change it globally. You can also manually move a file out preview mode using workbench.action.keepEditor which is bound by default to cmd+k+enter. But that's an obnoxious extra step.
I would like to selectively decide when I want to open in “preview” mode or in “edit” mode. Ideally I would like to bind something like shift+enter to do this. In my keybindings.json have tried variations on
{
"key": "shift+enter",
"command": "workbench.action.keepEditor",
"when": "inFilesPicker && inQuickOpen"
}
but with no luck :(
The answer to this question ALMOST does what I want:
vscode: Open file instead of previewing file from quick open
The proposed solution of using alt+enter opens the file in a new window. No bueno.
The proposed solution of using the right arrow key to open the file does work... but it does not close the Command Palette like hitting enter does. No bueno.
I do believe you will have to use a macro extension like multi-command. In your settings.json:
"multiCommand.commands": [
{
"command": "multiCommand.openFileNotInPreview",
"sequence": [
"workbench.action.acceptSelectedQuickOpenItem",
"workbench.action.keepEditor",
]
}
]
In keybindings.json some keybinding:
{
"key": "shift+right",
"command": "extension.multiCommand.execute",
"args": { "command": "multiCommand.openFileNotInPreview" },
"when": "inFilesPicker && inQuickOpen"
},
I used "shift+right" here, your "shift+enter" seemed to run into conflicts and would not work.
This will open your selected file in the Ctrl-P panel in a new editor in your same editor group and it will not be in preview mode.
As a Windows systems admin, I use PowerShell quite a lot. With the release of PS Core, and the implication that the ISE is dead, I've started to try to use VS Code as my day to day tool. One feature I'm missing from ISE is the ability to swap between the editor and the terminal in fullscreen. I usually kept ISE open and maximized, and used Ctrl+R to swap between editor and terminal as needed. I haven't found a way to maximize the terminal, and swap easily between terminal and editor. I know I can make the terminal take up most of the screen, but a) this still leaves about 2 lines of editor open at the top, and b) there doesn't seem to be an easy way to then maximize the editor. Is there a way to minic the ISE behaviour that I haven't found yet?
To toggle between a full screen editor and a nearly full screen terminal you can use:
{
"key": "ctrl+alt+m",
"command": "workbench.action.toggleMaximizedPanel"
}
with your keybinding of choice to replace the Ctrl-Alt-m : that is mine. You just need to "maximize" the terminal first - pull it up as far as it goes. It will remember that between sessions.
Revisiting this :
As of v1.38 this is now pretty simple. There are two commands that will toggle the panel/editors to full screen.
Pick some keybinding to use for the toggle trigger:
{
"key": "ctrl+alt+q",
"command": "workbench.action.toggleMaximizedPanel",
// "command": "workbench.action.toggleEditorVisibility" either one
"when": "!terminalFocus"
},
The above will expand the panel or editor to full height, but toggling back will return the panel to its original size but not to nothing. If you want the terminal to bounce between full open and full closed try both of these keybindings:
{
"key": "ctrl+alt+t", // you could use "key": "ctrl+`", if you wish
"command": "workbench.action.closePanel",
// "when": "terminalFocus"
},
{
"key": "ctrl+alt+t",
"command": "workbench.action.toggleMaximizedPanel",
"when": "!terminalFocus"
},
The order of the above 2 keybindings is important.
v1.50 is adding the setting panel.opensMaximized - I tried its different options but couldn't get a simpler result than the two keybindings ctrl+alt+t version I showed above. In any case, start with the panel closed for it to work well.
The below outlines my solution after reading #Mark 's answer, as it's slightly different. I use ctrl-alt-m to switch between a full-sized terminal and full-sized editor.
note: this includes the mentioned integrated terminal and vscode application menu bars.
For posterity's sake, I'm on vscode version 1.40.1.
Implementation
You'll need to add to your keybindings within vscode and execute a manual step.
keybindings.json
Add this to your keybindings.json file, accessible via the Keyboard Shortcuts editor:
{
"key": "ctrl+alt+m",
"command": "workbench.action.toggleMaximizedPanel",
"when": "!terminalFocus"
},
{
"key": "ctrl+`",
"command": "-workbench.action.terminal.toggleTerminal",
"when": "!terminalFocus"
},
{
"key": "ctrl+alt+m",
"command": "workbench.action.terminal.toggleTerminal",
"when": "terminalFocus"
}
Slide down the integrated terminal
Once you've done this and saved your keybindings.json file you need to manually slide down the integrated terminal all the way off the screen on the bottom, after opening from your editor with ctrl+`.
Afterwards, you should be able to use ctrl+alt+m in your editor and your terminal to get a full-screen-ish experience moving between them.
I've tested this on Ubuntu and Fedora locally as hosts and using remote-ssh to an Ubuntu remote from a Windows 10 host. This has the added benefit of allowing you to get the by-default smaller terminal from within your editor using ctrl+` but use a single command, ctrl+alt+m, for switching between editor/terminal. YMMV!
Solution 1: Create Terminal in new Tab and Switch Between Tabs
Ctrl+Shift+P > Terminal: Create New Terminal in Editor Area create a terminal as a new Tab (A.k.a. Editor). It looks like:
Now you can toggle between Tabs (A.k.a. Editors) and Terminal (Which is in a new Tab) using View: Quick Open Previous Recently Used Editor in Group
Solution 2: Create Terminal in new Editor Group and Switch Between Editor Groups
Ctrl+Shift+P > Terminal: Create New Terminal in Editor Area to the Side create a terminal in new Editor Groups. It looks like:
Now you can toggle between window and terminal using View: Navigate Between Editor Groups
NOTE:
You can add keybinding to the commands as per your convenience. For example, in case of Solution 1:
{
"key": "ctrl+`",
"command": "workbench.action.createTerminalEditor"
},
{
"key": "ctrl+tab",
"command": "workbench.action.quickOpenPreviousRecentlyUsedEditorInGroup",
"when": "!activeEditorGroupEmpty"
},
{
"key": "ctrl+w",
"command": "workbench.action.terminal.killEditor",
"when": "terminalEditorFocus && terminalFocus && terminalHasBeenCreated && resourceScheme == 'vscode-terminal' || terminalEditorFocus && terminalFocus && terminalProcessSupported && resourceScheme == 'vscode-terminal'"
}
Here, Ctrl+W & Ctrl+Tab are set by default. I just modified Ctrl+`.
The above keybinding will
Create terminal when you press Ctrl+`
Close terminal when you press Ctrl+W
Toggle between fullscreen editor and terminal when you press Ctrl+Tab
Opening the terminal in VS Code in full screen
This solution will replace the standard keybindings in VS Code so the terminal toggles in full screen.
Implementation
Open command palette ctrl+shift+p and search for Preferences: Open Keyboard Shortcuts (JSON) and paste this between the square brackets.
{ "key":"ctrl+j", "command":"workbench.action.toggleMaximizedPanel","when":"!terminalFocus" },
{ "key": "ctrl+oem_3", "command":"workbench.action.toggleMaximizedPanel", "when":"!terminalFocus" }
There is now an extension for exactly this. It is the "maximizeterminal" extension by Samuel T Scott. It redefines ctrl+` for opening terminal full-screen. The above keybinding methods, are also great, but in my experience they tend to not work properly once you start opening files by using cli like "code app.js". While using the extension such problems do not occur.
For macOS users, you can set the shortcut in the same keybindings.json file.
You can access the file using the shortcut cmd+shift+p, then write/select Preferences: Open Keyboard Shortcuts (JSON).
In keybindings.json, paste the following code between the square brackets:
{ "key": "cmd+alt+m",
"command": "workbench.action.toggleMaximizedPanel",
"when": "!terminalFocus" }
You can change the shortcut to whatever suits you (mind rewriting any of the default ones!), but I set mine to the same as others suggested (cmd+option+m) to keep a "standard".
Right click on the terminal instance name at the top as seen below and then select "move terminal into editor area". This will allow you to have a full workspace view within VS Code.
Image of process
I love this question, I believe I figured out something or at least got the behavior I was looking for.
Using the workspace setting here: https://github.com/microsoft/vscode/issues/107624
(enter ctrl+, and search "openmaximized" and set the dropdown to "always")
From there I set the keyboard shortcut for "Toggle Terminal" to ctrl+j (or whatever you may prefer) and now when I toggle my terminal it goes from full screen to toggled off
For MacOS I found useful cmd+option+m
Is there any way to set two keyboard shortcuts for one action in VS code? For example, I want to move the cursor to the left by pressing left arrow key or Alt+A.
Is it possible to add multiple keybindings to a shortcut?
Edit: Starting from 1.52 it's possible from keybindings GUI:
What stops you from editing keybindings.json?
{
"key": "left",
"command": "cursorLeft",
"when": "textInputFocus"
},
{
"key": "alt+a",
"command": "cursorLeft"
}
It can be opened from Command Palette Preferences: Open Keyboard Shortcuts (JSON)
Or by clicking the file icon from keybindings GUI page:
Updating the previous answer and adding tiny more details, atleast in the current 2020 version it seems like after changing the keybindings (atleasy cursor up & down), VSCode creates an entry in the JSON file that can be accessed from Alex's answer. The JSON will contain the new entry you made but also the changed entry with a '-' negative sign on the key instruction. Just remove the '-' negative sign and both your keybindings should work like a charm! Obviously don't forget to save!