make enableKeybindingHoldMode return a promise that resolves when hold-mode is over

Author: jrieken

src/vs/editor/standalone/browser/standaloneServices.ts

@@ -594,6 +594,13 @@ export class StandaloneKeybindingService extends AbstractKeybindingService {
 	public registerSchemaContribution(contribution: KeybindingsSchemaContribution): void {
 		// noop
 	}
+
+	/**
+	 * not yet supported
+	 */
+	public override enableKeybindingHoldMode(commandId: string): Promise<void> | undefined {
+		return undefined;
+	}
 }
 
 class DomNodeListeners extends Disposable {

src/vs/platform/keybinding/common/abstractKeybindingService.ts

@@ -53,8 +53,7 @@ export abstract class AbstractKeybindingService extends Disposable implements IK
 	private _ignoreSingleModifiers: KeybindingModifierSet;
 	private _currentSingleModifier: SingleModifierChord | null;
 	private _currentSingleModifierClearTimeout: TimeoutTimer;
-	private _currentlyDispatchingCommandId: string | null;
-	protected _isInKeybindingHoldMode: boolean;
+	protected _currentlyDispatchingCommandId: string | null;
 
 	protected _logging: boolean;
 
@@ -78,7 +77,6 @@ export abstract class AbstractKeybindingService extends Disposable implements IK
 		this._currentSingleModifier = null;
 		this._currentSingleModifierClearTimeout = new TimeoutTimer();
 		this._currentlyDispatchingCommandId = null;
-		this._isInKeybindingHoldMode = false;
 		this._logging = false;
 	}
 
@@ -387,14 +385,7 @@ export abstract class AbstractKeybindingService extends Disposable implements IK
 		}
 	}
 
-	enableKeybindingHoldMode(commandId: string): boolean {
-		if (this._currentlyDispatchingCommandId !== commandId) {
-			return false;
-		}
-		this._isInKeybindingHoldMode = true;
-		this._log(`+ Enabled hold-mode for ${commandId}.`);
-		return true;
-	}
+	abstract enableKeybindingHoldMode(commandId: string): Promise<void> | undefined;
 
 	mightProducePrintableCharacter(event: IKeyboardEvent): boolean {
 		if (event.ctrlKey || event.metaKey) {

src/vs/platform/keybinding/common/keybinding.ts

@@ -69,9 +69,9 @@ export interface IKeybindingService {
 	 * Enable hold mode for this command. This is only possible if the command is current being dispatched, meaning
 	 * we are after its keydown and before is keyup event.
 	 *
-	 * @returns true is hold mode was enabled
+	 * @returns A promise that resolves when hold stops, returns undefined if hold mode could not be enabled.
 	 */
-	enableKeybindingHoldMode(commandId: string): boolean;
+	enableKeybindingHoldMode(commandId: string): Promise<void> | undefined;
 
 	dispatchByUserSettingsLabel(userSettingsLabel: string, target: IContextKeyServiceTarget): void;
 

src/vs/platform/keybinding/test/common/abstractKeybindingService.test.ts

@@ -95,6 +95,10 @@ suite('AbstractKeybindingService', () => {
 		public registerSchemaContribution() {
 			// noop
 		}
+
+		public enableKeybindingHoldMode() {
+			return undefined;
+		}
 	}
 
 	let createTestKeybindingService: (items: ResolvedKeybindingItem[], contextValue?: any) => TestKeybindingService = null!;

src/vs/platform/keybinding/test/common/mockKeybindingService.ts

@@ -147,8 +147,8 @@ export class MockKeybindingService implements IKeybindingService {
 		return false;
 	}
 
-	public enableKeybindingHoldMode(commandId: string): boolean {
-		return false;
+	public enableKeybindingHoldMode(commandId: string): undefined {
+		return undefined;
 	}
 
 	public mightProducePrintableCharacter(e: IKeyboardEvent): boolean {

src/vs/workbench/contrib/inlineChat/electron-sandbox/inlineChatActions.ts

@@ -2,7 +2,6 @@
  *  Copyright (c) Microsoft Corporation. All rights reserved.
  *  Licensed under the MIT License. See License.txt in the project root for license information.
  *--------------------------------------------------------------------------------------------*/
-import * as dom from 'vs/base/browser/dom';
 import { KeyChord, KeyCode, KeyMod } from 'vs/base/common/keyCodes';
 import { ICodeEditor } from 'vs/editor/browser/editorBrowser';
 import { EditorAction2 } from 'vs/editor/browser/editorExtensions';
@@ -51,31 +50,26 @@ export class StartSessionAction extends EditorAction2 {
 
 		if (configService.getValue<boolean>(InlineChatConfigKeys.HoldToSpeech) // enabled
 			&& speechService.hasSpeechProvider  // possible
-			&& keybindingService.enableKeybindingHoldMode(this.desc.id) // holding keys
 		) {
 
+			const holdMode = keybindingService.enableKeybindingHoldMode(this.desc.id);
+			if (holdMode) { // holding keys
+				let listening = false;
+				const handle = disposableTimeout(() => {
+					// start VOICE input
+					commandService.executeCommand(StartVoiceChatAction.ID);
+					listening = true;
+				}, 100);
 
-			let listening = false;
-			const handle = disposableTimeout(() => {
-				// start VOICE input
-				commandService.executeCommand(StartVoiceChatAction.ID);
-				listening = true;
-			}, 100);
-
-			const listener = dom.addDisposableListener(
-				dom.getWindow(editor.getDomNode()),
-				dom.EventType.KEY_UP,
-				(_e: KeyboardEvent) => {
-					listener.dispose(); // Event.once
+				holdMode.finally(() => {
 					if (listening) {
 						commandService.executeCommand(StopListeningAction.ID).finally(() => {
 							InlineChatController.get(editor)?.acceptInput();
 						});
-					} else {
-						handle.dispose();
 					}
-				}
-			);
+					handle.dispose();
+				});
+			}
 		}
 
 		let options: InlineChatRunOptions | undefined;

src/vs/workbench/services/keybinding/browser/keybindingService.ts

@@ -10,7 +10,7 @@ import * as browser from 'vs/base/browser/browser';
 import { BrowserFeatures, KeyboardSupport } from 'vs/base/browser/canIUse';
 import * as dom from 'vs/base/browser/dom';
 import { printKeyboardEvent, printStandardKeyboardEvent, StandardKeyboardEvent } from 'vs/base/browser/keyboardEvent';
-import { RunOnceScheduler } from 'vs/base/common/async';
+import { DeferredPromise, RunOnceScheduler } from 'vs/base/common/async';
 import { Emitter, Event } from 'vs/base/common/event';
 import { parse } from 'vs/base/common/json';
 import { IJSONSchema } from 'vs/base/common/jsonSchema';
@@ -183,6 +183,7 @@ export class WorkbenchKeybindingService extends AbstractKeybindingService {
 	private _cachedResolver: KeybindingResolver | null;
 	private userKeybindings: UserKeybindings;
 	private isComposingGlobalContextKey: IContextKey<boolean>;
+	private _keybindingHoldMode: DeferredPromise<void> | null;
 	private readonly _contributions: KeybindingsSchemaContribution[] = [];
 	private readonly kbsJsonSchema: KeybindingsJsonSchema;
 
@@ -212,6 +213,7 @@ export class WorkbenchKeybindingService extends AbstractKeybindingService {
 			this.updateResolver();
 		});
 
+		this._keybindingHoldMode = null;
 		this._cachedResolver = null;
 
 		this.userKeybindings = this._register(new UserKeybindings(userDataProfileService, uriIdentityService, fileService, logService));
@@ -269,7 +271,7 @@ export class WorkbenchKeybindingService extends AbstractKeybindingService {
 
 		// for standard keybindings
 		disposables.add(dom.addDisposableListener(window, dom.EventType.KEY_DOWN, (e: KeyboardEvent) => {
-			if (this._isInKeybindingHoldMode) {
+			if (this._keybindingHoldMode) {
 				return;
 			}
 			this.isComposingGlobalContextKey.set(e.isComposing);
@@ -285,7 +287,10 @@ export class WorkbenchKeybindingService extends AbstractKeybindingService {
 
 		// for single modifier chord keybindings (e.g. shift shift)
 		disposables.add(dom.addDisposableListener(window, dom.EventType.KEY_UP, (e: KeyboardEvent) => {
-			this._isInKeybindingHoldMode = false;
+			if (this._keybindingHoldMode) {
+				this._keybindingHoldMode.complete();
+				this._keybindingHoldMode = null;
+			}
 			this.isComposingGlobalContextKey.set(e.isComposing);
 			const keyEvent = new StandardKeyboardEvent(e);
 			const shouldPreventDefault = this._singleModifierDispatch(keyEvent, keyEvent.target);
@@ -395,6 +400,15 @@ export class WorkbenchKeybindingService extends AbstractKeybindingService {
 		return JSON.stringify(info, null, '\t');
 	}
 
+	public override enableKeybindingHoldMode(commandId: string): Promise<void> | undefined {
+		if (this._currentlyDispatchingCommandId !== commandId) {
+			return undefined;
+		}
+		this._keybindingHoldMode = new DeferredPromise<void>();
+		this._log(`+ Enabled hold-mode for ${commandId}.`);
+		return this._keybindingHoldMode.p;
+	}
+
 	public override customKeybindingsCount(): number {
 		return this.userKeybindings.keybindings.length;
 	}