Adding accessibility help for verbose hover

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

@@ -355,6 +355,10 @@ export class ContentHoverController extends Disposable implements IHoverWidget {
 		this._markdownHoverParticipant?.updateFocusedMarkdownHoverPartVerbosityLevel(action);
 	}
 
+	public isFocusOnMarkdownHoverWhichSupportsVerbosityAction(action: HoverVerbosityAction): boolean {
+		return this._markdownHoverParticipant?.isFocusOnMarkdownHoverWhichSupportsVerbosityAction(action) ?? false;
+	}
+
 	public getWidgetContent(): string | undefined {
 		const node = this._widget.getDomNode();
 		if (!node.textContent) {

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

@@ -2,48 +2,101 @@
  *  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_ACTION_ID, INCREASE_HOVER_VERBOSITY_ACTION_ID } from 'vs/editor/contrib/hover/browser/hoverActionIds';
+import { AccessibilityVerbositySettingId } from 'vs/workbench/contrib/accessibility/browser/accessibilityConfiguration';
+import { ICodeEditor } from 'vs/editor/browser/editorBrowser';
+import { ICodeEditorService } from 'vs/editor/browser/services/codeEditorService';
+
+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 class HoverAccessibleView implements IAccessibleViewImplentation {
+
 	readonly type = AccessibleViewType.View;
 	readonly priority = 95;
 	readonly name = 'hover';
 	readonly when = EditorContextKeys.hoverFocused;
-	getProvider(accessor: ServicesAccessor) {
+
+	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;
+		let 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
-			}
-		};
+		return accessor.get(IInstantiationService).createInstance(HoverAccessibilityHelpProvider, codeEditor);
+	}
+}
+
+export class HoverAccessibilityHelpProvider implements IAccessibleViewContentProvider {
+
+	public readonly options: IAccessibleViewOptions;
+	public readonly id = AccessibleViewProviderId.Hover;
+	public readonly verbositySettingKey = AccessibilityVerbositySettingId.Hover;
+
+	constructor(
+		private readonly _editor: ICodeEditor,
+		@IKeybindingService private readonly _keybindingService: IKeybindingService
+	) {
+		this.options = {
+			language: this._editor.getModel()?.getLanguageId() ?? 'typescript',
+			type: AccessibleViewType.View
+		}
+	}
+
+	private _descriptionForCommand(commandId: string, msg: string, noKbMsg: string): string {
+		const kb = this._keybindingService.lookupKeybinding(commandId);
+		if (kb) {
+			return format(msg, kb.getAriaLabel());
+		}
+		return format(noKbMsg, commandId);
+	}
+
+	provideContent(): string {
+		const content: string[] = [];
+		content.push(HoverAccessibilityHelpNLS.intro);
+		const hoverController = HoverController.get(this._editor);
+		if (!hoverController) {
+			return content.join('\n');
+		}
+		const isFocusOnExpandableMarkdownHover = hoverController.isFocusOnMarkdownHoverWhichSupportsVerbosityAction(HoverVerbosityAction.Increase);
+		if (isFocusOnExpandableMarkdownHover) {
+			content.push(this._descriptionForCommand(INCREASE_HOVER_VERBOSITY_ACTION_ID, HoverAccessibilityHelpNLS.increaseVerbosity, HoverAccessibilityHelpNLS.increaseVerbosityNoKb));
+		}
+		const isFocusOnContractableMarkdownHover = hoverController.isFocusOnMarkdownHoverWhichSupportsVerbosityAction(HoverVerbosityAction.Decrease);
+		if (isFocusOnContractableMarkdownHover) {
+			content.push(this._descriptionForCommand(DECREASE_HOVER_VERBOSITY_ACTION_ID, HoverAccessibilityHelpNLS.decreaseVerbosity, HoverAccessibilityHelpNLS.decreaseVerbosityNoKb));
+		}
+		return content.join('\n');
+	}
+
+	onClose(): void {
+		HoverController.get(this._editor)?.focus();
 	}
 }
 
 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;

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

@@ -408,6 +408,10 @@ export class HoverController extends Disposable implements IEditorContribution {
 		this._getOrCreateContentWidget().updateFocusedMarkdownHoverVerbosityLevel(action);
 	}
 
+	public isFocusOnMarkdownHoverWhichSupportsVerbosityAction(action: HoverVerbosityAction): boolean {
+		return this._getOrCreateContentWidget().isFocusOnMarkdownHoverWhichSupportsVerbosityAction(action);
+	}
+
 	public focus(): void {
 		this._contentWidget?.focus();
 	}

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

@@ -194,6 +194,10 @@ export class MarkdownHoverParticipant implements IEditorHoverParticipant<Markdow
 	public updateFocusedMarkdownHoverPartVerbosityLevel(action: HoverVerbosityAction) {
 		this._renderedHoverParts?.updateFocusedHoverPartVerbosityLevel(action);
 	}
+
+	public isFocusOnMarkdownHoverWhichSupportsVerbosityAction(action: HoverVerbosityAction): boolean {
+		return this._renderedHoverParts?.isFocusOnMarkdownHoverWhichSupportsVerbosityAction(action) ?? false;
+	}
 }
 
 interface RenderedHoverPart {
@@ -378,6 +382,15 @@ class MarkdownRenderedHoverParts extends Disposable {
 		this._onFinishedRendering();
 	}
 
+	public isFocusOnMarkdownHoverWhichSupportsVerbosityAction(action: HoverVerbosityAction): boolean {
+		const hoverFocusedPartIndex = this._hoverFocusInfo.hoverPartIndex;
+		const hoverRenderedPart = this._getRenderedHoverPartAtIndex(hoverFocusedPartIndex);
+		if (!hoverRenderedPart || !hoverRenderedPart.hoverSource?.supportsVerbosityAction(action)) {
+			return false;
+		}
+		return true;
+	}
+
 	private _replaceRenderedHoverPartAtIndex(index: number, renderedHoverPart: RenderedHoverPart): void {
 		if (index >= this._renderHoverParts.length || index < 0) {
 			return;