Change:
VSCode Version: 1.1.1 OS Version: Windows 7 x64 It would be great if holding the key + spinning the mouse wheel would increase / decrease the VS Code zoom value.
I am not sure we want to zoom the entire UI when you use the mousewhell, I would expect only the editor font to increase. Thereby moving to
yes you are correct.
Didn't this feature used to work, or am I just failing to remember correctly? I was just going to report this as a bug, but maybe it never actually worked. I jump between different computer setups fairly regularly, so maybe I am just not remembering. Anyway, I found this dupe, and didn't want to submit a new issue. Thanks for your efforts By the way, I think I would expect this feature to work the same way that and work. VSCode's UI deviates from many other UIs in that it scales well, so I think I'd expect this to scale the entire UI consistently with the keyboard commands.
If this zooms only the editor, shouldn't it be seperate from ?
I would expect and to zoom only the editor. That behaviour would be consistent with most (all?) other editors and apps. Scaling the entire interface is an accessibility feature IMO, so maybe it doesn't need to use such a commonly used shortcut by default? Beyond Ctrl+Wheel, pinch to zoom should also zoom the editor.
Can this be disabled? I'm constantly accidentally zooming my text to a tiny size when I ctrl-click and accidentally brush my fingers over the trackpad.
This is disabled by default, so you must have enabled it in the past --
Thanks - I came here to vote for this feature, and it turns out I just had to turn it on! Shouldn't this issue be closed?
:+1: Closing since this is implemented. The feature is disabled by default due to numerous issues reported by users using touchpads where we begin to unexpectedly zoom in/zoom out when e.g. using ballistic scrolling and pressing the ctrl/cmd modifier. The root problem is that we cannot differentiate events coming in from a real mouse with a wheel from those coming in from touchpads / trackpads.

Discussion:
public static INSTANCE = new ZoomManager(); private _zoomLevel: number = 0; <ins> private _editorZoomLevel: number = 0; </ins> private _pixelRatioCache: number = 0; private _pixelRatioComputed: boolean = false; private _onDidChangeZoomLevel: Emitter<number> = new Emitter<number>(); public onDidChangeZoomLevel:Event<number> = this._onDidChangeZoomLevel.event; <ins> private _onDidChangeEditorZoomLevel: Emitter<number> = new Emitter<number>(); public onDidChangeEditorZoomLevel:Event<number> = this._onDidChangeEditorZoomLevel.event; </ins> public getZoomLevel(): number { return this._zoomLevel; }

this._onDidChangeZoomLevel.fire(this._zoomLevel); } <ins> public getEditorZoomLevel(): number { return this._editorZoomLevel; } public setEditorZoomLevel(zoomLevel:number): void { if (this._editorZoomLevel === zoomLevel) { return; } this._editorZoomLevel = zoomLevel; this._onDidChangeZoomLevel.fire(this._editorZoomLevel); } </ins> public getPixelRatio(): number { if (!this._pixelRatioComputed) { this._pixelRatioCache = this._computePixelRatio();

export function onDidChangeZoomLevel(callback:(zoomLevel:number)=>void): IDisposable { return ZoomManager.INSTANCE.onDidChangeZoomLevel(callback); } <ins> export function getEditorZoomLevel(): number { return ZoomManager.INSTANCE.getEditorZoomLevel(); } export function setEditorZoomLevel(zoomLevel:number): void { let zoomLevelNormalized = Math.min(Math.max(-9, zoomLevel), 9); ZoomManager.INSTANCE.setEditorZoomLevel(zoomLevelNormalized); } export function onDidChangeEditorZoomLevel(callback:(zoomLevel:number)=>void): IDisposable { return ZoomManager.INSTANCE.onDidChangeEditorZoomLevel(callback); } </ins> const userAgent = navigator.userAgent;

} private _onMouseWheel(e: StandardMouseWheelEvent): void { <ins> let browserEvent = e.browserEvent; if (browserEvent.ctrlKey){ let zoomLevel:number = Browser.getEditorZoomLevel(); let delta = e.deltaY > 0 ? 1 : -1; zoomLevel += delta; Browser.setEditorZoomLevel(zoomLevel); return; } </ins> if (Platform.isMacintosh && e.browserEvent && this._options.saveLastScrollTimeOnClassName) { // Mark dom node with timestamp of wheel event let target = <HTMLElement>e.browserEvent.target;

} this._register(browser.onDidChangeZoomLevel(_ => this._recomputeOptions())); <ins> this._register(browser.onDidChangeEditorZoomLevel(_ => this._recomputeOptions())); </ins> } private _onReferenceDomElementSizeChanged(): void {

import * as editorCommon from 'vs/editor/common/editorCommon'; import {EditorLayoutProvider} from 'vs/editor/common/viewLayout/editorLayoutProvider'; import {ScrollbarVisibility} from 'vs/base/browser/ui/scrollbar/scrollableElementOptions'; <ins> import * as browser from 'vs/base/browser/browser'; </ins> /** * Experimental screen reader support toggle

if (lineHeight === 0) { lineHeight = Math.round(GOLDEN_LINE_HEIGHT_RATIO * fontSize); } <ins> let editorZoomLevelMultiplier = 1 + (browser.getEditorZoomLevel() * 0.1); fontSize *= editorZoomLevelMultiplier; lineHeight *= editorZoomLevelMultiplier; </ins> return InternalEditorOptionsHelper.createInternalEditorOptions( this.getOuterWidth(),