Adding accessibility help for verbose hover

src/vs/editor/contrib/hover/browser/contentHoverController.ts

@@ -23,6 +23,7 @@ import { ContentHoverWidget } from 'vs/editor/contrib/hover/browser/contentHover
 import { ContentHoverComputer } from 'vs/editor/contrib/hover/browser/contentHoverComputer';
 import { ContentHoverVisibleData, HoverResult } from 'vs/editor/contrib/hover/browser/contentHoverTypes';
 import { EditorHoverStatusBar } from 'vs/editor/contrib/hover/browser/contentHoverStatusBar';
+import { Emitter } from 'vs/base/common/event';
 
 export class ContentHoverController extends Disposable implements IHoverWidget {
 
@@ -35,6 +36,9 @@ export class ContentHoverController extends Disposable implements IHoverWidget {
 	private readonly _markdownHoverParticipant: MarkdownHoverParticipant | undefined;
 	private readonly _hoverOperation: HoverOperation<IHoverPart>;
 
+	private readonly _onContentsChanged = this._register(new Emitter<void>());
+	public readonly onContentsChanged = this._onContentsChanged.event;
+
 	constructor(
 		private readonly _editor: ICodeEditor,
 		@IInstantiationService private readonly _instantiationService: IInstantiationService,
@@ -214,7 +218,7 @@ export class ContentHoverController extends Disposable implements IHoverWidget {
 			fragment,
 			statusBar,
 			setColorPicker: (widget) => colorPicker = widget,
-			onContentsChanged: () => this._widget.onContentsChanged(),
+			onContentsChanged: () => this._doOnContentsChanged(),
 			setMinimumDimensions: (dimensions: dom.Dimension) => this._widget.setMinimumDimensions(dimensions),
 			hide: () => this.hide()
 		};
@@ -261,6 +265,11 @@ export class ContentHoverController extends Disposable implements IHoverWidget {
 		}
 	}
 
+	private _doOnContentsChanged(): void {
+		this._onContentsChanged.fire();
+		this._widget.onContentsChanged();
+	}
+
 	private static readonly _DECORATION_OPTIONS = ModelDecorationOptions.register({
 		description: 'content-hover-highlight',
 		className: 'hoverHighlight'
@@ -351,8 +360,20 @@ export class ContentHoverController extends Disposable implements IHoverWidget {
 		this._startShowingOrUpdateHover(new HoverRangeAnchor(0, range, undefined, undefined), mode, source, focus, null);
 	}
 
-	public async updateFocusedMarkdownHoverVerbosityLevel(action: HoverVerbosityAction): Promise<void> {
-		this._markdownHoverParticipant?.updateFocusedMarkdownHoverPartVerbosityLevel(action);
+	public async updateMarkdownHoverVerbosityLevel(action: HoverVerbosityAction, index?: number, focus?: boolean): Promise<void> {
+		this._markdownHoverParticipant?.updateMarkdownHoverVerbosityLevel(action, index, focus);
+	}
+
+	public focusedMarkdownHoverIndex(): number {
+		return this._markdownHoverParticipant?.focusedMarkdownHoverIndex() ?? -1;
+	}
+
+	public markdownHoverContentAtIndex(index: number): string {
+		return this._markdownHoverParticipant?.markdownHoverContentAtIndex(index) ?? '';
+	}
+
+	public doesMarkdownHoverAtIndexSupportVerbosityAction(index: number, action: HoverVerbosityAction): boolean {
+		return this._markdownHoverParticipant?.doesMarkdownHoverAtIndexSupportVerbosityAction(index, action) ?? false;
 	}
 
 	public getWidgetContent(): string | undefined {

src/vs/editor/contrib/hover/browser/hoverAccessibleViews.ts

@@ -2,48 +2,205 @@
  *  Copyright (c) Microsoft Corporation. All rights reserved.
  *  Licensed under the MIT License. See License.txt in the project root for license information.
  *--------------------------------------------------------------------------------------------*/
-
-import { ICodeEditorService } from 'vs/editor/browser/services/codeEditorService';
+import { localize } from 'vs/nls';
+import { format } from 'vs/base/common/strings';
 import { EditorContextKeys } from 'vs/editor/common/editorContextKeys';
 import { HoverController } from 'vs/editor/contrib/hover/browser/hoverController';
-import { AccessibleViewType, AccessibleViewProviderId } from 'vs/platform/accessibility/browser/accessibleView';
+import { AccessibleViewType, AccessibleViewProviderId, AdvancedContentProvider, IAccessibleViewContentProvider, IAccessibleViewOptions } from 'vs/platform/accessibility/browser/accessibleView';
 import { IAccessibleViewImplentation } from 'vs/platform/accessibility/browser/accessibleViewRegistry';
 import { IContextViewService } from 'vs/platform/contextview/browser/contextView';
 import { IHoverService } from 'vs/platform/hover/browser/hover';
-import { ServicesAccessor } from 'vs/platform/instantiation/common/instantiation';
+import { IInstantiationService, ServicesAccessor } from 'vs/platform/instantiation/common/instantiation';
+import { IKeybindingService } from 'vs/platform/keybinding/common/keybinding';
+import { HoverVerbosityAction } from 'vs/editor/common/languages';
+import { DECREASE_HOVER_VERBOSITY_ACCESSIBLE_ACTION_ID, DECREASE_HOVER_VERBOSITY_ACTION_ID, DECREASE_HOVER_VERBOSITY_ACTION_LABEL, INCREASE_HOVER_VERBOSITY_ACCESSIBLE_ACTION_ID, INCREASE_HOVER_VERBOSITY_ACTION_ID, INCREASE_HOVER_VERBOSITY_ACTION_LABEL } from 'vs/editor/contrib/hover/browser/hoverActionIds';
+import { ICodeEditor } from 'vs/editor/browser/editorBrowser';
+import { ICodeEditorService } from 'vs/editor/browser/services/codeEditorService';
+import { Action, IAction } from 'vs/base/common/actions';
+import { ThemeIcon } from 'vs/base/common/themables';
+import { Codicon } from 'vs/base/common/codicons';
+import { Emitter, Event } from 'vs/base/common/event';
+import { Disposable, IDisposable } from 'vs/base/common/lifecycle';
+
+namespace HoverAccessibilityHelpNLS {
+	export const intro = localize('intro', "The hover widget is focused. Press the Tab key to cycle through the hover parts.");
+	export const increaseVerbosity = localize('increaseVerbosity', "- The focused hover part verbosity level can be increased ({0}).");
+	export const increaseVerbosityNoKb = localize('increaseVerbosityNoKb', "- The focused hover part verbosity level can be increased, which is currently not triggerable via keybinding.");
+	export const decreaseVerbosity = localize('decreaseVerbosity', "- The focused hover part verbosity level can be decreased ({0}).");
+	export const decreaseVerbosityNoKb = localize('decreaseVerbosityNoKb', "- The focused hover part verbosity level can be decreased, which is currently not triggerable via keybinding.");
+	export const hoverContent = localize('contentHover', "The last focused hover content is the following.");
+}
 
 export class HoverAccessibleView implements IAccessibleViewImplentation {
+
 	readonly type = AccessibleViewType.View;
 	readonly priority = 95;
 	readonly name = 'hover';
 	readonly when = EditorContextKeys.hoverFocused;
-	getProvider(accessor: ServicesAccessor) {
+
+	private _provider: HoverAccessibilityHelpProvider | undefined;
+
+	getProvider(accessor: ServicesAccessor): AdvancedContentProvider | undefined {
 		const codeEditorService = accessor.get(ICodeEditorService);
-		const editor = codeEditorService.getActiveCodeEditor() || codeEditorService.getFocusedCodeEditor();
-		const editorHoverContent = editor ? HoverController.get(editor)?.getWidgetContent() ?? undefined : undefined;
-		if (!editor || !editorHoverContent) {
-			return;
+		const codeEditor = codeEditorService.getActiveCodeEditor() || codeEditorService.getFocusedCodeEditor();
+		if (!codeEditor) {
+			return undefined;
 		}
-		return {
-			id: AccessibleViewProviderId.Hover,
-			verbositySettingKey: 'accessibility.verbosity.hover',
-			provideContent() { return editorHoverContent; },
-			onClose() {
-				HoverController.get(editor)?.focus();
-			},
-			options: {
-				language: editor?.getModel()?.getLanguageId() ?? 'typescript',
-				type: AccessibleViewType.View
-			}
+		this._provider = accessor.get(IInstantiationService).createInstance(HoverAccessibilityHelpProvider, codeEditor);
+		return this._provider;
+	}
+
+	dispose(): void {
+		this._provider?.dispose();
+	}
+}
+
+export class HoverAccessibilityHelpProvider extends Disposable implements IAccessibleViewContentProvider {
+
+	public readonly options: IAccessibleViewOptions;
+	public readonly id = AccessibleViewProviderId.Hover;
+	public readonly verbositySettingKey = 'accessibility.verbosity.hover';
+	public readonly actions: IAction[] = [];
+
+	private readonly _hoverController: HoverController | null = null;
+	private _onHoverContentsChanged: IDisposable | undefined;
+	private _markdownHoverFocusedIndex: number = -1;
+
+	private _onDidChangeContent: Emitter<void> = this._register(new Emitter<void>());
+	public onDidChangeContent: Event<void> = this._onDidChangeContent.event;
+
+	constructor(
+		private readonly _editor: ICodeEditor,
+		@IKeybindingService private readonly _keybindingService: IKeybindingService
+	) {
+		super();
+		this.options = {
+			language: this._editor.getModel()?.getLanguageId(),
+			type: AccessibleViewType.View
 		};
+		this._hoverController = HoverController.get(this._editor);
+		this._initializeActions();
+	}
+
+	public provideContent(): string {
+		const content: string[] = [HoverAccessibilityHelpNLS.intro];
+		if (!this._hoverController) {
+			return content.join('\n');
+		}
+		content.push(...this._descriptionsOfVerbosityActions(this._hoverController));
+		content.push(...this._descriptionOfFocusedMarkdownHover(this._hoverController));
+		return content.join('\n');
+	}
+
+	public onOpen(): void {
+		if (!this._hoverController) {
+			return;
+		}
+		this._hoverController.shouldKeepOpenOnEditorMouseMoveOrLeave = true;
+		this._markdownHoverFocusedIndex = this._hoverController.focusedMarkdownHoverIndex();
+		this._onHoverContentsChanged = this._register(this._hoverController.onHoverContentsChanged(() => {
+			this._onDidChangeContent.fire();
+		}));
+	}
+
+	public onClose(): void {
+		if (!this._hoverController) {
+			return;
+		}
+		this._markdownHoverFocusedIndex = -1;
+		this._hoverController.focus();
+		this._hoverController.shouldKeepOpenOnEditorMouseMoveOrLeave = false;
+		this._onHoverContentsChanged?.dispose();
+	}
+
+	private _initializeActions(): void {
+		this.actions.push(this._getActionFor(HoverVerbosityAction.Increase));
+		this.actions.push(this._getActionFor(HoverVerbosityAction.Decrease));
+	}
+
+	private _getActionFor(action: HoverVerbosityAction): IAction {
+		let actionId: string;
+		let accessibleActionId: string;
+		let actionLabel: string;
+		let actionCodicon: ThemeIcon;
+		switch (action) {
+			case HoverVerbosityAction.Increase:
+				actionId = INCREASE_HOVER_VERBOSITY_ACTION_ID;
+				accessibleActionId = INCREASE_HOVER_VERBOSITY_ACCESSIBLE_ACTION_ID;
+				actionLabel = INCREASE_HOVER_VERBOSITY_ACTION_LABEL;
+				actionCodicon = Codicon.add;
+				break;
+			case HoverVerbosityAction.Decrease:
+				actionId = DECREASE_HOVER_VERBOSITY_ACTION_ID;
+				accessibleActionId = DECREASE_HOVER_VERBOSITY_ACCESSIBLE_ACTION_ID;
+				actionLabel = DECREASE_HOVER_VERBOSITY_ACTION_LABEL;
+				actionCodicon = Codicon.remove;
+				break;
+		}
+		return new Action(accessibleActionId, actionLabel, ThemeIcon.asClassName(actionCodicon), true, () => {
+			this._editor.getAction(actionId)?.run({ index: this._markdownHoverFocusedIndex, focus: false });
+		});
+	}
+
+	private _descriptionsOfVerbosityActions(hoverController: HoverController): string[] {
+		const content: string[] = [];
+		const descriptionForIncreaseAction = this._descriptionOfVerbosityAction(hoverController, HoverVerbosityAction.Increase);
+		if (descriptionForIncreaseAction !== undefined) {
+			content.push(descriptionForIncreaseAction);
+		}
+		const descriptionForDecreaseAction = this._descriptionOfVerbosityAction(hoverController, HoverVerbosityAction.Decrease);
+		if (descriptionForDecreaseAction !== undefined) {
+			content.push(descriptionForDecreaseAction);
+		}
+		return content;
+	}
+
+	private _descriptionOfVerbosityAction(hoverController: HoverController, action: HoverVerbosityAction): string | undefined {
+		const isActionSupported = hoverController.doesMarkdownHoverAtIndexSupportVerbosityAction(this._markdownHoverFocusedIndex, action);
+		if (!isActionSupported) {
+			return;
+		}
+		let actionId: string;
+		let descriptionWithKb: string;
+		let descriptionWithoutKb: string;
+		switch (action) {
+			case HoverVerbosityAction.Increase:
+				actionId = INCREASE_HOVER_VERBOSITY_ACTION_ID;
+				descriptionWithKb = HoverAccessibilityHelpNLS.increaseVerbosity;
+				descriptionWithoutKb = HoverAccessibilityHelpNLS.increaseVerbosityNoKb;
+				break;
+			case HoverVerbosityAction.Decrease:
+				actionId = DECREASE_HOVER_VERBOSITY_ACTION_ID;
+				descriptionWithKb = HoverAccessibilityHelpNLS.decreaseVerbosity;
+				descriptionWithoutKb = HoverAccessibilityHelpNLS.decreaseVerbosityNoKb;
+				break;
+		}
+		return this._descriptionForCommand(actionId, descriptionWithKb, descriptionWithoutKb);
+	}
+
+	private _descriptionForCommand(commandId: string, msg: string, noKbMsg: string): string {
+		const kb = this._keybindingService.lookupKeybinding(commandId);
+		return kb ? format(msg, kb.getAriaLabel()) : format(noKbMsg, commandId);
+	}
+
+	private _descriptionOfFocusedMarkdownHover(hoverController: HoverController): string[] {
+		const content: string[] = [];
+		const hoverContent = hoverController.markdownHoverContentAtIndex(this._markdownHoverFocusedIndex);
+		if (hoverContent) {
+			content.push('\n' + HoverAccessibilityHelpNLS.hoverContent);
+			content.push('\n' + hoverContent);
+		}
+		return content;
 	}
 }
 
 export class ExtHoverAccessibleView implements IAccessibleViewImplentation {
+
 	readonly type = AccessibleViewType.View;
 	readonly priority = 90;
 	readonly name = 'extension-hover';
-	getProvider(accessor: ServicesAccessor) {
+
+	getProvider(accessor: ServicesAccessor): AdvancedContentProvider | undefined {
 		const contextViewService = accessor.get(IContextViewService);
 		const contextViewElement = contextViewService.getContextViewElement();
 		const extensionHoverContent = contextViewElement?.textContent ?? undefined;
@@ -63,4 +220,6 @@ export class ExtHoverAccessibleView implements IAccessibleViewImplentation {
 			options: { language: 'typescript', type: AccessibleViewType.View }
 		};
 	}
+
+	dispose() { }
 }

src/vs/editor/contrib/hover/browser/hoverActionIds.ts

@@ -2,6 +2,7 @@
  *  Copyright (c) Microsoft Corporation. All rights reserved.
  *  Licensed under the MIT License. See License.txt in the project root for license information.
  *--------------------------------------------------------------------------------------------*/
+import * as nls from 'vs/nls';
 
 export const SHOW_OR_FOCUS_HOVER_ACTION_ID = 'editor.action.showHover';
 export const SHOW_DEFINITION_PREVIEW_HOVER_ACTION_ID = 'editor.action.showDefinitionPreviewHover';
@@ -14,4 +15,8 @@ export const PAGE_DOWN_HOVER_ACTION_ID = 'editor.action.pageDownHover';
 export const GO_TO_TOP_HOVER_ACTION_ID = 'editor.action.goToTopHover';
 export const GO_TO_BOTTOM_HOVER_ACTION_ID = 'editor.action.goToBottomHover';
 export const INCREASE_HOVER_VERBOSITY_ACTION_ID = 'editor.action.increaseHoverVerbosityLevel';
+export const INCREASE_HOVER_VERBOSITY_ACCESSIBLE_ACTION_ID = 'editor.action.increaseHoverVerbosityLevelFromAccessibleView';
+export const INCREASE_HOVER_VERBOSITY_ACTION_LABEL = nls.localize({ key: 'increaseHoverVerbosityLevel', comment: ['Label for action that will increase the hover verbosity level.'] }, "Increase Hover Verbosity Level");
 export const DECREASE_HOVER_VERBOSITY_ACTION_ID = 'editor.action.decreaseHoverVerbosityLevel';
+export const DECREASE_HOVER_VERBOSITY_ACCESSIBLE_ACTION_ID = 'editor.action.decreaseHoverVerbosityLevelFromAccessibleView';
+export const DECREASE_HOVER_VERBOSITY_ACTION_LABEL = nls.localize({ key: 'decreaseHoverVerbosityLevel', comment: ['Label for action that will decrease the hover verbosity level.'] }, "Decrease Hover Verbosity Level");

src/vs/editor/contrib/hover/browser/hoverActions.ts

@@ -3,7 +3,7 @@
  *  Licensed under the MIT License. See License.txt in the project root for license information.
  *--------------------------------------------------------------------------------------------*/
 
-import { DECREASE_HOVER_VERBOSITY_ACTION_ID, GO_TO_BOTTOM_HOVER_ACTION_ID, GO_TO_TOP_HOVER_ACTION_ID, INCREASE_HOVER_VERBOSITY_ACTION_ID, PAGE_DOWN_HOVER_ACTION_ID, PAGE_UP_HOVER_ACTION_ID, SCROLL_DOWN_HOVER_ACTION_ID, SCROLL_LEFT_HOVER_ACTION_ID, SCROLL_RIGHT_HOVER_ACTION_ID, SCROLL_UP_HOVER_ACTION_ID, SHOW_DEFINITION_PREVIEW_HOVER_ACTION_ID, SHOW_OR_FOCUS_HOVER_ACTION_ID } from 'vs/editor/contrib/hover/browser/hoverActionIds';
+import { DECREASE_HOVER_VERBOSITY_ACTION_ID, DECREASE_HOVER_VERBOSITY_ACTION_LABEL, GO_TO_BOTTOM_HOVER_ACTION_ID, GO_TO_TOP_HOVER_ACTION_ID, INCREASE_HOVER_VERBOSITY_ACTION_ID, INCREASE_HOVER_VERBOSITY_ACTION_LABEL, PAGE_DOWN_HOVER_ACTION_ID, PAGE_UP_HOVER_ACTION_ID, SCROLL_DOWN_HOVER_ACTION_ID, SCROLL_LEFT_HOVER_ACTION_ID, SCROLL_RIGHT_HOVER_ACTION_ID, SCROLL_UP_HOVER_ACTION_ID, SHOW_DEFINITION_PREVIEW_HOVER_ACTION_ID, SHOW_OR_FOCUS_HOVER_ACTION_ID } from 'vs/editor/contrib/hover/browser/hoverActionIds';
 import { KeyChord, KeyCode, KeyMod } from 'vs/base/common/keyCodes';
 import { ICodeEditor } from 'vs/editor/browser/editorBrowser';
 import { EditorAction, ServicesAccessor } from 'vs/editor/browser/editorExtensions';
@@ -425,17 +425,14 @@ export class IncreaseHoverVerbosityLevel extends EditorAction {
 	constructor() {
 		super({
 			id: INCREASE_HOVER_VERBOSITY_ACTION_ID,
-			label: nls.localize({
-				key: 'increaseHoverVerbosityLevel',
-				comment: ['Label for action that will increase the hover verbosity level.']
-			}, "Increase Hover Verbosity Level"),
+			label: INCREASE_HOVER_VERBOSITY_ACTION_LABEL,
 			alias: 'Increase Hover Verbosity Level',
-			precondition: EditorContextKeys.hoverFocused
+			precondition: EditorContextKeys.hoverVisible
 		});
 	}
 
-	public run(accessor: ServicesAccessor, editor: ICodeEditor): void {
-		HoverController.get(editor)?.updateFocusedMarkdownHoverVerbosityLevel(HoverVerbosityAction.Increase);
+	public run(accessor: ServicesAccessor, editor: ICodeEditor, args?: { index: number; focus: boolean }): void {
+		HoverController.get(editor)?.updateMarkdownHoverVerbosityLevel(HoverVerbosityAction.Increase, args?.index, args?.focus);
 	}
 }
 
@@ -444,16 +441,13 @@ export class DecreaseHoverVerbosityLevel extends EditorAction {
 	constructor() {
 		super({
 			id: DECREASE_HOVER_VERBOSITY_ACTION_ID,
-			label: nls.localize({
-				key: 'decreaseHoverVerbosityLevel',
-				comment: ['Label for action that will decrease the hover verbosity level.']
-			}, "Decrease Hover Verbosity Level"),
+			label: DECREASE_HOVER_VERBOSITY_ACTION_LABEL,
 			alias: 'Decrease Hover Verbosity Level',
-			precondition: EditorContextKeys.hoverFocused
+			precondition: EditorContextKeys.hoverVisible
 		});
 	}
 
-	public run(accessor: ServicesAccessor, editor: ICodeEditor, args: any): void {
-		HoverController.get(editor)?.updateFocusedMarkdownHoverVerbosityLevel(HoverVerbosityAction.Decrease);
+	public run(accessor: ServicesAccessor, editor: ICodeEditor, args?: { index: number; focus: boolean }): void {
+		HoverController.get(editor)?.updateMarkdownHoverVerbosityLevel(HoverVerbosityAction.Decrease, args?.index, args?.focus);
 	}
 }