@eclipse-glsp/client 1.1.0-next.35bf56e.230 → 1.1.0-next.36bcf27.277

package/src/features/accessibility/resize-key-tool/resize-key-handler.ts

@@ -0,0 +1,129 @@
+/********************************************************************************
+ * Copyright (c) 2023 Business Informatics Group (TU Wien) and others.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the Eclipse
+ * Public License v. 2.0 are satisfied: GNU General Public License, version 2
+ * with the GNU Classpath Exception which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ ********************************************************************************/
+
+import { inject, injectable, optional } from 'inversify';
+import {
+    Action,
+    ChangeBoundsOperation,
+    Dimension,
+    IActionDispatcher,
+    IActionHandler,
+    ICommand,
+    ISnapper,
+    Point,
+    SModelElement,
+    SParentElement,
+    TYPES
+} from '~glsp-sprotty';
+import { EditorContextService } from '../../../base/editor-context-service';
+import { isValidMove, isValidSize, minHeight, minWidth } from '../../../utils/layout-utils';
+import { SelectableBoundsAware, getElements, isSelectableAndBoundsAware, toElementAndBounds } from '../../../utils/smodel-util';
+import { Resizable } from '../../change-bounds/model';
+import { GridSnapper } from '../../change-bounds/snap';
+
+export enum ResizeType {
+    Increase,
+    Decrease,
+    MinSize
+}
+
+/**
+ * Action for triggering resizing of elements.
+ */
+export interface ResizeElementAction extends Action {
+    kind: typeof ResizeElementAction.KIND;
+    elementIds: string[];
+    resizeType: ResizeType;
+}
+export namespace ResizeElementAction {
+    export const KIND = 'resizeElementAction';
+
+    export function is(object: any): object is ResizeElementAction {
+        return Action.hasKind(object, KIND);
+    }
+
+    export function create(elementIds: string[], resizeType: ResizeType): ResizeElementAction {
+        return { kind: KIND, elementIds, resizeType };
+    }
+}
+
+/* The ResizeElementHandler class is an implementation of the IActionHandler interface that handles
+resizing of elements. */
+@injectable()
+export class ResizeElementHandler implements IActionHandler {
+    @inject(EditorContextService)
+    protected editorContextService: EditorContextService;
+
+    @inject(TYPES.IActionDispatcher) protected dispatcher: IActionDispatcher;
+
+    // Default x resize used if GridSnapper is not provided
+    static readonly defaultResizeX = 20;
+
+    // Default y resize used if GridSnapper is not provided
+    static readonly defaultResizeY = 20;
+    protected grid = { x: ResizeElementHandler.defaultResizeX, y: ResizeElementHandler.defaultResizeY };
+
+    protected isEditMode = false;
+
+    constructor(@inject(TYPES.ISnapper) @optional() protected readonly snapper?: ISnapper) {
+        if (snapper instanceof GridSnapper) {
+            this.grid = snapper.grid;
+        }
+    }
+
+    handle(action: Action): void | Action | ICommand {
+        if (ResizeElementAction.is(action)) {
+            this.handleResizeElement(action);
+        }
+    }
+
+    handleResizeElement(action: ResizeElementAction): void {
+        const elements = getElements(this.editorContextService.modelRoot.index, action.elementIds, isSelectableAndBoundsAware);
+        this.dispatcher.dispatchAll(this.resize(elements, action));
+    }
+
+    protected resize(elements: SelectableBoundsAware[], action: ResizeElementAction): Action[] {
+        const actions: Action[] = [];
+
+        elements.forEach(element => {
+            const { x, y, width: oldWidth, height: oldHeight } = element.bounds;
+            let width = 0;
+            let height = 0;
+
+            if (action.resizeType === ResizeType.Decrease) {
+                width = oldWidth - this.grid.x;
+                height = oldHeight - this.grid.y;
+            } else if (action.resizeType === ResizeType.Increase) {
+                width = oldWidth + this.grid.x;
+                height = oldHeight + this.grid.y;
+            } else if (action.resizeType === ResizeType.MinSize) {
+                width = minWidth(element);
+                height = minHeight(element);
+            }
+
+            if (this.isValidBoundChange(element, { x, y }, { width, height })) {
+                const resizeElement = { id: element.id, bounds: { x, y, width, height } } as SModelElement & SParentElement & Resizable;
+                actions.push(ChangeBoundsOperation.create([toElementAndBounds(resizeElement)]));
+            }
+        });
+
+        return actions;
+    }
+
+    protected isValidBoundChange(element: SelectableBoundsAware, newPosition: Point, newSize: Dimension): boolean {
+        return isValidSize(element, newSize) && isValidMove(element, newPosition);
+    }
+}

package/src/features/accessibility/resize-key-tool/resize-key-module.ts

@@ -0,0 +1,34 @@
+/********************************************************************************
+ * Copyright (c) 2023 Business Informatics Group (TU Wien) and others.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the Eclipse
+ * Public License v. 2.0 are satisfied: GNU General Public License, version 2
+ * with the GNU Classpath Exception which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ ********************************************************************************/
+
+import { BindingContext, FeatureModule, TYPES, bindAsService, configureActionHandler } from '~glsp-sprotty';
+import { ResizeElementAction, ResizeElementHandler } from './resize-key-handler';
+import { ResizeKeyTool } from './resize-key-tool';
+
+/**
+ * Handles resize actions.
+ */
+export const resizeKeyModule = new FeatureModule((bind, unbind, isBound, rebind) => {
+    const context = { bind, unbind, isBound, rebind };
+    configureResizeTools(context);
+});
+
+export function configureResizeTools(context: BindingContext): void {
+    context.bind(ResizeElementHandler).toSelf().inSingletonScope();
+
+    configureActionHandler(context, ResizeElementAction.KIND, ResizeElementHandler);
+    bindAsService(context, TYPES.IDefaultTool, ResizeKeyTool);
+}

package/src/features/accessibility/resize-key-tool/resize-key-tool.ts

@@ -0,0 +1,143 @@
+/********************************************************************************
+ * Copyright (c) 2023 Business Informatics Group (TU Wien) and others.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the Eclipse
+ * Public License v. 2.0 are satisfied: GNU General Public License, version 2
+ * with the GNU Classpath Exception which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ ********************************************************************************/
+
+import { inject, injectable, optional } from 'inversify';
+import { matchesKeystroke } from 'sprotty/lib/utils/keyboard';
+import { Action, ISnapper, KeyListener, KeyTool, SModelElement, TYPES } from '~glsp-sprotty';
+import { GLSPActionDispatcher } from '../../../base/action-dispatcher';
+import { SelectionService } from '../../../base/selection-service';
+import { EnableDefaultToolsAction, EnableToolsAction, Tool } from '../../../base/tool-manager/tool';
+import { IMovementRestrictor } from '../../change-bounds/movement-restrictor';
+import { AccessibleKeyShortcutProvider, SetAccessibleKeyShortcutAction } from '../key-shortcut/accessible-key-shortcut';
+import { ResizeElementAction, ResizeType } from './resize-key-handler';
+import { ShowToastMessageAction } from '../toast/toast-handler';
+import * as messages from '../toast/messages.json';
+
+@injectable()
+export class ResizeKeyTool implements Tool {
+    static ID = 'glsp.resize-key-tool';
+
+    isEditTool = true;
+
+    @inject(KeyTool) protected readonly keytool: KeyTool;
+    @inject(TYPES.IMovementRestrictor) @optional() readonly movementRestrictor?: IMovementRestrictor;
+    @inject(TYPES.ISnapper) @optional() readonly snapper?: ISnapper;
+    @inject(TYPES.IActionDispatcher) readonly actionDispatcher: GLSPActionDispatcher;
+    @inject(SelectionService) readonly selectionService: SelectionService;
+
+    protected resizeKeyListener: ResizeKeyListener = new ResizeKeyListener(this);
+
+    get id(): string {
+        return ResizeKeyTool.ID;
+    }
+
+    enable(): void {
+        this.keytool.register(this.resizeKeyListener);
+        this.resizeKeyListener.registerShortcutKey();
+    }
+
+    disable(): void {
+        this.keytool.deregister(this.resizeKeyListener);
+    }
+}
+@injectable()
+export class ResizeKeyListener extends KeyListener implements AccessibleKeyShortcutProvider {
+    protected isEditMode = false;
+    protected readonly token = ResizeKeyListener.name;
+
+    constructor(protected readonly tool: ResizeKeyTool) {
+        super();
+    }
+
+    registerShortcutKey(): void {
+        this.tool.actionDispatcher.onceModelInitialized().then(() => {
+            this.tool.actionDispatcher.dispatchAll([
+                SetAccessibleKeyShortcutAction.create({
+                    token: this.token,
+                    keys: [
+                        { shortcuts: ['ALT', 'A'], description: 'Activate resize mode for selected element', group: 'Resize', position: 0 },
+                        { shortcuts: ['+'], description: 'Increase size of element', group: 'Resize', position: 1 },
+                        { shortcuts: ['-'], description: 'Increase size of element', group: 'Resize', position: 2 },
+                        { shortcuts: ['CTRL', '0'], description: 'Set element size to default', group: 'Resize', position: 3 }
+                    ]
+                })
+            ]);
+        });
+    }
+
+    override keyDown(element: SModelElement, event: KeyboardEvent): Action[] {
+        const actions = [];
+        const selectedElementsIds = this.tool.selectionService.getSelectedElementIDs();
+
+        if (this.isEditMode && this.matchesDeactivateResizeModeKeystroke(event)) {
+            this.isEditMode = false;
+
+            this.tool.actionDispatcher.dispatch(
+                ShowToastMessageAction.createWithTimeout({
+                    id: Symbol.for(ResizeKeyListener.name),
+                    message: messages.resize.resize_mode_deactivated
+                })
+            );
+
+            actions.push(EnableDefaultToolsAction.create());
+        }
+
+        if (selectedElementsIds.length > 0) {
+            if (!this.isEditMode && this.matchesActivateResizeModeKeystroke(event)) {
+                this.isEditMode = true;
+                this.tool.actionDispatcher.dispatch(
+                    ShowToastMessageAction.create({
+                        id: Symbol.for(ResizeKeyListener.name),
+                        message: messages.resize.resize_mode_activated
+                    })
+                );
+                actions.push(EnableToolsAction.create([ResizeKeyTool.ID]));
+            }
+
+            if (this.isEditMode) {
+                if (this.matchesIncreaseSizeKeystroke(event)) {
+                    actions.push(ResizeElementAction.create(selectedElementsIds, ResizeType.Increase));
+                } else if (this.matchesDecreaseSizeKeystroke(event)) {
+                    actions.push(ResizeElementAction.create(selectedElementsIds, ResizeType.Decrease));
+                } else if (this.matchesMinSizeKeystroke(event)) {
+                    actions.push(ResizeElementAction.create(selectedElementsIds, ResizeType.MinSize));
+                }
+            }
+        }
+        return actions;
+    }
+
+    protected matchesIncreaseSizeKeystroke(event: KeyboardEvent): boolean {
+        /** here event.key is used for '+', as keycode 187 is already declared for 'Equals' in {@link matchesKeystroke}.*/
+        return event.key === '+' || matchesKeystroke(event, 'NumpadAdd');
+    }
+
+    protected matchesActivateResizeModeKeystroke(event: KeyboardEvent): boolean {
+        return matchesKeystroke(event, 'KeyA', 'alt');
+    }
+
+    protected matchesDeactivateResizeModeKeystroke(event: KeyboardEvent): boolean {
+        return matchesKeystroke(event, 'Escape');
+    }
+
+    protected matchesMinSizeKeystroke(event: KeyboardEvent): boolean {
+        return matchesKeystroke(event, 'Digit0', 'ctrl') || matchesKeystroke(event, 'Numpad0', 'ctrl');
+    }
+
+    protected matchesDecreaseSizeKeystroke(event: KeyboardEvent): boolean {
+        return matchesKeystroke(event, 'Minus') || matchesKeystroke(event, 'NumpadSubtract');
+    }
+}

package/src/features/accessibility/search/search-palette-module.ts

@@ -0,0 +1,29 @@
+/********************************************************************************
+ * Copyright (c) 2023 Business Informatics Group (TU Wien) and others.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the Eclipse
+ * Public License v. 2.0 are satisfied: GNU General Public License, version 2
+ * with the GNU Classpath Exception which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ ********************************************************************************/
+
+import { bindAsService, BindingContext, FeatureModule, TYPES } from '~glsp-sprotty';
+import { SearchAutocompletePalette } from './search-palette';
+import { SearchAutocompletePaletteTool } from './search-tool';
+
+export const searchPaletteModule = new FeatureModule((bind, _unbind, isBound, rebind) => {
+    const context = { bind, isBound, rebind };
+    configureSearchPaletteModule(context);
+});
+
+export function configureSearchPaletteModule(context: Pick<BindingContext, 'bind'>): void {
+    bindAsService(context, TYPES.IUIExtension, SearchAutocompletePalette);
+    bindAsService(context, TYPES.IDefaultTool, SearchAutocompletePaletteTool);
+}

package/src/features/accessibility/search/search-palette.ts

@@ -0,0 +1,195 @@
+/********************************************************************************
+ * Copyright (c) 2023 Business Informatics Group (TU Wien) and others.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the Eclipse
+ * Public License v. 2.0 are satisfied: GNU General Public License, version 2
+ * with the GNU Classpath Exception which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ ********************************************************************************/
+
+import { injectable } from 'inversify';
+import { isEqual } from 'lodash';
+import { toArray } from 'sprotty/lib/utils/iterable';
+import {
+    Action,
+    CenterAction,
+    LabeledAction,
+    SEdge,
+    SModelElement,
+    SModelRoot,
+    SNode,
+    SelectAction,
+    SelectAllAction,
+    codiconCSSString,
+    isNameable,
+    name
+} from '~glsp-sprotty';
+import { AutocompleteSuggestion, IAutocompleteSuggestionProvider } from '../../autocomplete-palette/autocomplete-suggestion-providers';
+import { BaseAutocompletePalette } from '../../autocomplete-palette/base-autocomplete-palette';
+
+import { applyCssClasses, deleteCssClasses } from '../../../base/feedback/css-feedback';
+import { RepositionAction } from '../../../features/viewport/reposition';
+
+const CSS_SEARCH_HIDDEN = 'search-hidden';
+const CSS_SEARCH_HIGHLIGHTED = 'search-highlighted';
+
+export class RevealNamedElementAutocompleteSuggestionProvider implements IAutocompleteSuggestionProvider {
+    async retrieveSuggestions(root: Readonly<SModelRoot>, text: string): Promise<AutocompleteSuggestion[]> {
+        const nameables = toArray(root.index.all().filter(element => isNameable(element)));
+        return nameables.map(nameable => ({
+            element: nameable,
+            action: {
+                label: `[${nameable.type}] ${name(nameable) ?? '<no-name>'}`,
+                actions: this.getActions(nameable),
+                icon: codiconCSSString('eye')
+            }
+        }));
+    }
+
+    protected getActions(nameable: SModelElement): Action[] {
+        return [SelectAction.create({ selectedElementsIDs: [nameable.id] }), CenterAction.create([nameable.id], { retainZoom: true })];
+    }
+}
+
+export class RevealEdgeElementAutocompleteSuggestionProvider implements IAutocompleteSuggestionProvider {
+    async retrieveSuggestions(root: Readonly<SModelRoot>, text: string): Promise<AutocompleteSuggestion[]> {
+        const edges = toArray(root.index.all().filter(element => element instanceof SEdge)) as SEdge[];
+        return edges.map(edge => ({
+            element: edge,
+            action: {
+                label: `[${edge.type}]  ${this.getEdgeLabel(root, edge)}`,
+                actions: this.getActions(edge),
+                icon: codiconCSSString('arrow-both')
+            }
+        }));
+    }
+    protected getActions(edge: SEdge): Action[] {
+        return [SelectAction.create({ selectedElementsIDs: [edge.id] }), CenterAction.create([edge.sourceId, edge.targetId])];
+    }
+    protected getEdgeLabel(root: Readonly<SModelRoot>, edge: SEdge): string {
+        let sourceName = '';
+        let targetName = '';
+
+        const sourceNode = root.index.getById(edge.sourceId);
+        const targetNode = root.index.getById(edge.targetId);
+
+        if (sourceNode !== undefined) {
+            sourceName = name(sourceNode) ?? sourceNode.type;
+        }
+        if (targetNode !== undefined) {
+            targetName = name(targetNode) ?? targetNode.type;
+        }
+
+        return sourceName + ' -> ' + targetName;
+    }
+}
+@injectable()
+export class SearchAutocompletePalette extends BaseAutocompletePalette {
+    static readonly ID = 'search-autocomplete-palette';
+
+    protected cachedSuggestions: AutocompleteSuggestion[] = [];
+
+    id(): string {
+        return SearchAutocompletePalette.ID;
+    }
+
+    protected override initializeContents(containerElement: HTMLElement): void {
+        super.initializeContents(containerElement);
+
+        this.autocompleteWidget.inputField.placeholder = 'Search for elements';
+        containerElement.setAttribute('aria-label', 'Search Field');
+    }
+    protected getSuggestionProviders(root: Readonly<SModelRoot>, input: string): IAutocompleteSuggestionProvider[] {
+        return [new RevealNamedElementAutocompleteSuggestionProvider(), new RevealEdgeElementAutocompleteSuggestionProvider()];
+    }
+    protected async retrieveSuggestions(root: Readonly<SModelRoot>, input: string): Promise<LabeledAction[]> {
+        const providers = this.getSuggestionProviders(root, input);
+        const suggestions = (await Promise.all(providers.map(provider => provider.retrieveSuggestions(root, input)))).flat(1);
+
+        this.cachedSuggestions = suggestions;
+
+        return suggestions.map(s => s.action);
+    }
+
+    protected override async visibleSuggestionsChanged(root: Readonly<SModelRoot>, labeledActions: LabeledAction[]): Promise<void> {
+        await this.applyCSS(this.getHiddenElements(root, this.getSuggestionsFromLabeledActions(labeledActions)), CSS_SEARCH_HIDDEN);
+        await this.deleteCSS(
+            this.getSuggestionsFromLabeledActions(labeledActions).map(s => s.element),
+            CSS_SEARCH_HIDDEN
+        );
+    }
+
+    protected override async selectedSuggestionChanged(
+        root: Readonly<SModelRoot>,
+        labeledAction?: LabeledAction | undefined
+    ): Promise<void> {
+        await this.deleteAllCSS(root, CSS_SEARCH_HIGHLIGHTED);
+        if (labeledAction !== undefined) {
+            const suggestions = this.getSuggestionsFromLabeledActions([labeledAction]);
+
+            const actions: RepositionAction[] = [];
+            suggestions.map(currElem => actions.push(RepositionAction.create([currElem.element.id])));
+
+            this.actionDispatcher.dispatchAll(actions);
+            await this.applyCSS(
+                suggestions.map(s => s.element),
+                CSS_SEARCH_HIGHLIGHTED
+            );
+        }
+    }
+
+    public override show(root: Readonly<SModelRoot>, ...contextElementIds: string[]): void {
+        this.actionDispatcher.dispatch(SelectAllAction.create(false));
+
+        super.show(root, ...contextElementIds);
+    }
+
+    public override hide(): void {
+        if (this.root !== undefined) {
+            this.deleteAllCSS(this.root, CSS_SEARCH_HIDDEN);
+            this.deleteAllCSS(this.root, CSS_SEARCH_HIGHLIGHTED);
+            this.autocompleteWidget.inputField.value = '';
+        }
+
+        super.hide();
+    }
+
+    protected applyCSS(elements: SModelElement[], cssClass: string): Promise<void> {
+        const actions = elements.map(element => applyCssClasses(element, cssClass));
+        return this.actionDispatcher.dispatchAll(actions);
+    }
+
+    protected deleteCSS(elements: SModelElement[], cssClass: string): Promise<void> {
+        const actions = elements.map(element => deleteCssClasses(element, cssClass));
+        return this.actionDispatcher.dispatchAll(actions);
+    }
+
+    protected deleteAllCSS(root: Readonly<SModelRoot>, cssClass: string): Promise<void> {
+        const actions = toArray(root.index.all().map(element => deleteCssClasses(element, cssClass)));
+        return this.actionDispatcher.dispatchAll(actions);
+    }
+
+    protected getSuggestionsFromLabeledActions(labeledActions: LabeledAction[]): AutocompleteSuggestion[] {
+        return this.cachedSuggestions.filter(c => labeledActions.find(s => isEqual(s, c.action)));
+    }
+
+    protected getHiddenSuggestionsFromLabeledActions(labeledActions: LabeledAction[]): AutocompleteSuggestion[] {
+        return this.cachedSuggestions.filter(c => !labeledActions.find(s => isEqual(s, c.action)));
+    }
+
+    protected getHiddenElements(root: Readonly<SModelRoot>, suggestions: AutocompleteSuggestion[]): SModelElement[] {
+        return toArray(
+            root.index
+                .all()
+                .filter(element => element instanceof SNode || element instanceof SEdge)
+                .filter(element => suggestions.find(suggestion => suggestion.element.id === element.id) === undefined)
+        );
+    }
+}

package/src/features/accessibility/search/search-tool.ts

@@ -0,0 +1,79 @@
+/********************************************************************************
+ * Copyright (c) 2023 Business Informatics Group (TU Wien) and others.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the Eclipse
+ * Public License v. 2.0 are satisfied: GNU General Public License, version 2
+ * with the GNU Classpath Exception which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ ********************************************************************************/
+
+import { inject, injectable } from 'inversify';
+import { matchesKeystroke } from 'sprotty/lib/utils/keyboard';
+import { Action, KeyListener, KeyTool, SModelElement, SetUIExtensionVisibilityAction, TYPES } from '~glsp-sprotty';
+import { GLSPActionDispatcher } from '../../../base/action-dispatcher';
+import { Tool } from '../../../base/tool-manager/tool';
+import { AccessibleKeyShortcutProvider, SetAccessibleKeyShortcutAction } from '../key-shortcut/accessible-key-shortcut';
+import { SearchAutocompletePalette } from './search-palette';
+@injectable()
+export class SearchAutocompletePaletteTool implements Tool {
+    static readonly ID = 'glsp.search-autocomplete-palette-tool';
+
+    protected readonly keyListener = new SearchAutocompletePaletteKeyListener(this);
+    @inject(TYPES.IActionDispatcher) readonly actionDispatcher: GLSPActionDispatcher;
+    @inject(KeyTool) protected keyTool: KeyTool;
+
+    get id(): string {
+        return SearchAutocompletePaletteTool.ID;
+    }
+
+    enable(): void {
+        this.keyTool.register(this.keyListener);
+        this.keyListener.registerShortcutKey();
+    }
+
+    disable(): void {
+        this.keyTool.deregister(this.keyListener);
+    }
+}
+
+export class SearchAutocompletePaletteKeyListener extends KeyListener implements AccessibleKeyShortcutProvider {
+    protected readonly token = SearchAutocompletePalette.name;
+
+    constructor(protected tool: SearchAutocompletePaletteTool) {
+        super();
+    }
+
+    registerShortcutKey(): void {
+        this.tool.actionDispatcher.onceModelInitialized().then(() => {
+            this.tool.actionDispatcher.dispatchAll([
+                SetAccessibleKeyShortcutAction.create({
+                    token: this.token,
+                    keys: [{ shortcuts: ['CTRL', 'F'], description: 'Activate search for elements', group: 'Search', position: 0 }]
+                })
+            ]);
+        });
+    }
+
+    override keyDown(element: SModelElement, event: KeyboardEvent): Action[] {
+        if (this.matchesSearchActivateKeystroke(event)) {
+            return [
+                SetUIExtensionVisibilityAction.create({
+                    extensionId: SearchAutocompletePalette.ID,
+                    visible: true
+                })
+            ];
+        }
+        return [];
+    }
+
+    protected matchesSearchActivateKeystroke(event: KeyboardEvent): boolean {
+        return matchesKeystroke(event, 'KeyF', 'ctrl');
+    }
+}

package/src/features/accessibility/toast/messages.json

@@ -0,0 +1,16 @@
+{
+  "navigation": {
+    "default_navigation_mode_activated": "Navigation On: Use arrow keys to select preceding (←) or succeding (→) elements. Use the up (↑) and down (↓) arrows to navigate paths. Press 'N' to exit.",
+    "default_navigation_mode_deactivated": "Navigation Off: Press 'N' for default navigation, 'ALT+N' for position based navigation.",
+    "local_navigation_mode_activated": "Position based Nav On: Navigate nearest elements using arrow keys: (↑) for above, (↓) for below, (←) for previous, (→) for next element. Press 'ALT+N' to exit.",
+    "local_navigation_mode_deactivated": "Position based Nav Off: Press 'N' for default navigation, 'ALT+N' for position based navigation."
+  },
+  "focus": {
+    "focus_on": "Currently focused: ",
+    "focus_off": "Currently no element is focused."
+  },
+  "resize": {
+    "resize_mode_activated": "Resize On: Use plus(+) and minus(-) to resize, 'CTRL'+'0' for default size. Press 'ESC' to exit.",
+    "resize_mode_deactivated": "Resize Off: Press 'ALT'+'A' for resize mode."
+  }
+}