@eclipse-glsp/client 1.1.0-next.fdfeeeb.193 → 2.0.0

package/src/features/accessibility/key-shortcut/accessible-key-shortcut.ts

@@ -0,0 +1,197 @@
+/********************************************************************************
+ * 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 { groupBy } from 'lodash';
+import { AbstractUIExtension, Action, IActionHandler, ICommand, matchesKeystroke, GModelRoot } from '@eclipse-glsp/sprotty';
+
+export interface AccessibleKeyShortcutProvider {
+    registerShortcutKey(): void;
+}
+
+export interface AccessibleKeyShortcut {
+    shortcuts: string[];
+    description: string;
+    group: string;
+    position: number;
+}
+
+export interface SetAccessibleKeyShortcutAction extends Action {
+    kind: typeof SetAccessibleKeyShortcutAction.KIND;
+    token: string;
+    keys: AccessibleKeyShortcut[];
+}
+
+export namespace SetAccessibleKeyShortcutAction {
+    export const KIND = 'setAccessibleKeyShortcut';
+
+    export function is(object: any): object is SetAccessibleKeyShortcutAction {
+        return Action.hasKind(object, KIND);
+    }
+
+    export function create(options: { token: string; keys: AccessibleKeyShortcut[] }): SetAccessibleKeyShortcutAction {
+        return { kind: KIND, token: options.token, keys: options.keys };
+    }
+}
+
+@injectable()
+export class KeyShortcutUIExtension extends AbstractUIExtension implements IActionHandler {
+    static readonly ID = 'key-shortcut';
+    protected container: HTMLDivElement;
+    protected shortcutsContainer: HTMLDivElement;
+    protected registrations: Record<string, AccessibleKeyShortcut[]> = {};
+
+    handle(action: Action): ICommand | Action | void {
+        if (SetAccessibleKeyShortcutAction.is(action)) {
+            this.registrations[action.token] = action.keys;
+            if (this.containerElement) {
+                this.refreshUI();
+            }
+        }
+    }
+    id(): string {
+        return KeyShortcutUIExtension.ID;
+    }
+
+    containerClass(): string {
+        return KeyShortcutUIExtension.ID;
+    }
+
+    override show(root: Readonly<GModelRoot>, ...contextElementIds: string[]): void {
+        super.show(root, ...contextElementIds);
+        this.shortcutsContainer.focus();
+    }
+
+    protected refreshUI(): void {
+        this.shortcutsContainer.innerHTML = '';
+
+        const registrations = Object.values(this.registrations).flatMap(r => r);
+        registrations.sort((a, b) => {
+            if (a.group < b.group) {
+                return -1;
+            }
+            if (a.group > b.group) {
+                return 1;
+            }
+
+            return a.position - b.position;
+        });
+
+        const grouped = groupBy(registrations, k => k.group);
+
+        const groupTable = document.createElement('table');
+        groupTable.classList.add('shortcut-table');
+        const tableHead = document.createElement('thead');
+        const tableBody = document.createElement('tbody');
+
+        const headerRow = document.createElement('tr');
+        const commandCell = document.createElement('th');
+        const keybindingCell = document.createElement('th');
+
+        commandCell.classList.add('column-title');
+
+        commandCell.innerText = 'Command';
+        keybindingCell.innerText = 'Keybinding';
+
+        headerRow.appendChild(commandCell);
+        headerRow.appendChild(keybindingCell);
+        tableHead.appendChild(headerRow);
+
+        for (const [group, shortcuts] of Object.entries(grouped)) {
+            tableBody.appendChild(this.createGroupHeader(group));
+            shortcuts.forEach(s => {
+                tableBody.appendChild(this.createEntry(s));
+            });
+        }
+
+        groupTable.appendChild(tableHead);
+        groupTable.appendChild(tableBody);
+
+        this.shortcutsContainer.append(groupTable);
+    }
+
+    protected createGroupHeader(group: string): HTMLElement {
+        const entryRow = document.createElement('tr');
+        const groupElement = document.createElement('td');
+        const text = document.createElement('strong');
+        const emptyElement = document.createElement('td');
+
+        text.innerText = group;
+        groupElement.appendChild(text);
+        entryRow.appendChild(groupElement);
+        entryRow.appendChild(emptyElement);
+
+        return entryRow;
+    }
+
+    protected getShortcutHTML(shortcuts: string[]): HTMLElement {
+        const shortcutKeys = document.createElement('span');
+        shortcutKeys.innerHTML = shortcuts.map(key => `<kbd>${key}</kbd>`).join(' + ');
+
+        return shortcutKeys;
+    }
+
+    protected createEntry(registration: AccessibleKeyShortcut): HTMLDivElement {
+        const entryRow = document.createElement('tr');
+        const shortcutElement = document.createElement('td');
+        const descElement = document.createElement('td');
+
+        const shortcut = this.getShortcutHTML(registration.shortcuts);
+        descElement.innerText = registration.description;
+
+        shortcutElement.appendChild(shortcut);
+        entryRow.appendChild(descElement);
+        entryRow.appendChild(shortcutElement);
+
+        return entryRow;
+    }
+
+    protected initializeContents(containerElement: HTMLElement): void {
+        this.container = document.createElement('div');
+        this.container.classList.add('keyboard-shortcuts-menu');
+
+        // create title
+        const menuTitle = document.createElement('h3');
+        menuTitle.classList.add('menu-header');
+        menuTitle.innerText = 'Keyboard Shortcuts';
+        this.container.appendChild(menuTitle);
+
+        const closeBtn = document.createElement('button');
+        closeBtn.id = 'key-shortcut-close-btn';
+        closeBtn.textContent = 'x';
+        closeBtn.addEventListener('click', () => {
+            this.hide();
+        });
+
+        this.container.appendChild(closeBtn);
+
+        // create shortcuts container
+        this.shortcutsContainer = document.createElement('div');
+        this.shortcutsContainer.classList.add('keyboard-shortcuts-container');
+        this.shortcutsContainer.tabIndex = 30;
+        this.shortcutsContainer.addEventListener('keydown', (event: KeyboardEvent) => {
+            if (event.key === 'Escape' || matchesKeystroke(event, 'KeyH', 'alt')) {
+                this.hide();
+            }
+        });
+
+        this.container.appendChild(this.shortcutsContainer);
+        containerElement.appendChild(this.container);
+        containerElement.ariaLabel = 'Shortcut-Menu';
+
+        this.refreshUI();
+    }
+}

package/src/features/accessibility/key-shortcut/di.config.ts

@@ -0,0 +1,35 @@
+/********************************************************************************
+ * 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 { ContainerModule } from 'inversify';
+import { bindAsService, BindingContext, configureActionHandler, TYPES } from '@eclipse-glsp/sprotty';
+import '../../../../css/key-shortcut.css';
+import { KeyShortcutUIExtension, SetAccessibleKeyShortcutAction } from './accessible-key-shortcut';
+import { AccessibleKeyShortcutTool } from './accessible-key-shortcut-tool';
+
+/**
+ * Handles actions for displaying help/information about keyboard shortcuts.
+ */
+export const glspShortcutHelpModule = new ContainerModule((bind, unbind, isBound, rebind) => {
+    const context = { bind, unbind, isBound, rebind };
+    configureShortcutHelpTool(context);
+});
+
+export function configureShortcutHelpTool(context: BindingContext): void {
+    bindAsService(context, TYPES.IDefaultTool, AccessibleKeyShortcutTool);
+    bindAsService(context, TYPES.IUIExtension, KeyShortcutUIExtension);
+    configureActionHandler(context, SetAccessibleKeyShortcutAction.KIND, KeyShortcutUIExtension);
+}

package/src/features/accessibility/keyboard-grid/action.ts

@@ -0,0 +1,93 @@
+/********************************************************************************
+ * 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 { Action, hasObjectProp, Point } from '@eclipse-glsp/sprotty';
+
+export interface EnableKeyboardGridAction extends Action {
+    kind: typeof EnableKeyboardGridAction.KIND;
+    options: EnableKeyboardGridAction.Options;
+}
+
+export namespace EnableKeyboardGridAction {
+    export const KIND = 'enableKeyboardGrid';
+
+    export interface Options {
+        originId: string;
+        triggerActions: Action[];
+    }
+
+    export function is(object: any): object is EnableKeyboardGridAction {
+        return Action.hasKind(object, KIND) && hasObjectProp(object, 'options');
+    }
+
+    export function create(options: Options): EnableKeyboardGridAction {
+        return {
+            kind: KIND,
+            options
+        };
+    }
+}
+
+export interface KeyboardGridCellSelectedAction extends Action {
+    kind: typeof KeyboardGridCellSelectedAction.KIND;
+    options: KeyboardGridCellSelectedAction.Options;
+}
+
+export namespace KeyboardGridCellSelectedAction {
+    export const KIND = 'keyboardGridCellSelectedAction';
+
+    export interface Options {
+        originId: string;
+        cellId: string;
+        centerCellPosition: Point;
+    }
+
+    export function is(object: any): object is KeyboardGridCellSelectedAction {
+        return Action.hasKind(object, KIND) && hasObjectProp(object, 'options');
+    }
+
+    export function create(options: Options): KeyboardGridCellSelectedAction {
+        return {
+            kind: KIND,
+            options
+        };
+    }
+}
+
+export interface KeyboardGridKeyboardEventAction extends Action {
+    kind: typeof KeyboardGridKeyboardEventAction.KIND;
+    options: KeyboardGridKeyboardEventAction.Options;
+}
+
+export namespace KeyboardGridKeyboardEventAction {
+    export const KIND = 'keyboardGridKeyboardEvent';
+
+    export interface Options {
+        originId: string;
+        event: KeyboardEvent;
+    }
+
+    export function is(object: any): object is KeyboardGridKeyboardEventAction {
+        return Action.hasKind(object, KIND) && hasObjectProp(object, 'options');
+    }
+
+    export function create(options: Options): KeyboardGridKeyboardEventAction {
+        return {
+            kind: KIND,
+            options
+        };
+    }
+}

package/src/features/accessibility/keyboard-grid/constants.ts

@@ -0,0 +1,24 @@
+/********************************************************************************
+ * 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
+ ********************************************************************************/
+
+export namespace KeyboardGridMetadata {
+    export const ID = 'keyboard-grid';
+    export const TAB_INDEX = 15;
+}
+
+export namespace KeyboardNodeGridMetadata {
+    export const ID = 'keyboard-node-grid';
+}

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

@@ -0,0 +1,65 @@
+/********************************************************************************
+ * 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 '../../../../css/keyboard.css';
+
+import { Action, GModelElement, GModelRoot, SetUIExtensionVisibilityAction } from '@eclipse-glsp/sprotty';
+import { injectable } from 'inversify';
+import { IAutocompleteSuggestionProvider } from '../../../base/auto-complete/autocomplete-suggestion-providers';
+import {
+    RevealEdgeElementAutocompleteSuggestionProvider,
+    RevealNamedElementAutocompleteSuggestionProvider,
+    SearchAutocompletePalette
+} from '../search/search-palette';
+import { KeyboardGridMetadata } from './constants';
+import { GEdge } from '../../../model';
+
+export namespace GridSearchPaletteMetadata {
+    export const ID = 'grid-search-palette';
+}
+
+@injectable()
+export class GridSearchPalette extends SearchAutocompletePalette {
+    override id(): string {
+        return GridSearchPaletteMetadata.ID;
+    }
+
+    protected override getSuggestionProviders(root: Readonly<GModelRoot>, input: string): IAutocompleteSuggestionProvider[] {
+        return [new GridRevealNamedElementSuggestionProvider(), new GridRevealEdgeSuggestionProvider()];
+    }
+}
+
+export class GridRevealEdgeSuggestionProvider extends RevealEdgeElementAutocompleteSuggestionProvider {
+    protected override getActions(edge: GEdge): Action[] {
+        return [
+            ...super.getActions(edge),
+            SetUIExtensionVisibilityAction.create({
+                extensionId: KeyboardGridMetadata.ID,
+                visible: true
+            })
+        ];
+    }
+}
+export class GridRevealNamedElementSuggestionProvider extends RevealNamedElementAutocompleteSuggestionProvider {
+    protected override getActions(nameable: GModelElement): Action[] {
+        return [
+            ...super.getActions(nameable),
+            SetUIExtensionVisibilityAction.create({
+                extensionId: KeyboardGridMetadata.ID,
+                visible: true
+            })
+        ];
+    }
+}

package/src/features/accessibility/keyboard-grid/keyboard-grid.ts

@@ -0,0 +1,192 @@
+/********************************************************************************
+ * 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 '../../../../css/keyboard.css';
+
+import { inject, injectable } from 'inversify';
+import {
+    AbstractUIExtension,
+    ActionDispatcher,
+    IActionHandler,
+    SetUIExtensionVisibilityAction,
+    GModelRoot,
+    TYPES,
+    Action,
+    ICommand,
+    Point
+} from '@eclipse-glsp/sprotty';
+import { KeyCode, matchesKeystroke } from 'sprotty/lib/utils/keyboard';
+import { KeyboardGridMetadata } from './constants';
+import { EnableKeyboardGridAction, KeyboardGridCellSelectedAction, KeyboardGridKeyboardEventAction } from './action';
+
+@injectable()
+export class KeyboardGrid extends AbstractUIExtension implements IActionHandler {
+    @inject(TYPES.IActionDispatcher) protected readonly actionDispatcher: ActionDispatcher;
+
+    protected triggerActions: Action[] = [];
+    protected originId: string;
+
+    id(): string {
+        return KeyboardGridMetadata.ID;
+    }
+
+    containerClass(): string {
+        return KeyboardGridMetadata.ID;
+    }
+    handle(action: Action): void | Action | ICommand {
+        if (EnableKeyboardGridAction.is(action)) {
+            this.triggerActions = action.options.triggerActions;
+            this.originId = action.options.originId;
+            this.actionDispatcher.dispatch(
+                SetUIExtensionVisibilityAction.create({
+                    extensionId: KeyboardGridMetadata.ID,
+                    visible: true
+                })
+            );
+        }
+    }
+
+    protected initializeContents(containerElement: HTMLElement): void {
+        containerElement.tabIndex = KeyboardGridMetadata.TAB_INDEX;
+        containerElement.classList.add('grid-container');
+
+        for (let i = 1; i <= 9; i++) {
+            const gridNumber = document.createElement('div');
+            const gridItem = document.createElement('div');
+
+            gridItem.classList.add('grid-item');
+            gridItem.id = `keyboard-grid-item-${i}`;
+
+            gridNumber.classList.add('grid-item-number');
+            gridNumber.innerHTML = i.toString();
+
+            gridItem.appendChild(gridNumber);
+            containerElement.appendChild(gridItem);
+        }
+
+        this.containerElement.onkeydown = ev => {
+            this.onKeyDown(ev);
+        };
+    }
+
+    protected onKeyDown(event: KeyboardEvent): void {
+        this.activateCellIfDigitEvent(event);
+        this.hideIfEscapeEvent(event);
+
+        this.actionDispatcher.dispatch(
+            KeyboardGridKeyboardEventAction.create({
+                originId: this.originId,
+                event
+            })
+        );
+    }
+
+    protected override setContainerVisible(visible: boolean): void {
+        if (this.containerElement) {
+            if (visible) {
+                this.containerElement.style.visibility = 'visible';
+                this.containerElement.style.opacity = '0.7';
+            } else {
+                this.containerElement.style.visibility = 'hidden';
+                this.containerElement.style.opacity = '0';
+            }
+        }
+    }
+
+    override show(root: Readonly<GModelRoot>, ...contextElementIds: string[]): void {
+        super.show(root, ...contextElementIds);
+        this.containerElement.focus();
+    }
+
+    protected hideIfEscapeEvent(event: KeyboardEvent): any {
+        if (this.matchesDeactivateGrid(event)) {
+            this.hide();
+        }
+    }
+
+    protected activateCellIfDigitEvent(event: KeyboardEvent): any {
+        let index: number | undefined = undefined;
+
+        for (let i = 1; i <= 9; i++) {
+            if (this.matchesGridBoxAtIndex(event, i)) {
+                index = i;
+                break;
+            }
+        }
+
+        if (index !== undefined) {
+            const position = this.centerPositionOfCell(index);
+
+            this.dispatchActionsForCell(index, position);
+        }
+    }
+
+    protected dispatchActionsForCell(index: number, cellCenter: Point): void {
+        this.actionDispatcher.dispatchAll([
+            ...this.triggerActions,
+            KeyboardGridCellSelectedAction.create({
+                originId: this.originId,
+                cellId: index.toString(),
+                centerCellPosition: cellCenter
+            })
+        ]);
+    }
+    protected centerPositionOfCell(index: number): Point {
+        let x = 0;
+        let y = 0;
+
+        const activeGridCell = document.getElementById(`keyboard-grid-item-${index}`);
+        // eslint-disable-next-line no-null/no-null
+        if (activeGridCell !== null) {
+            const positions = this.getCenterOfCell(activeGridCell);
+            x = positions[0];
+            y = positions[1];
+        }
+
+        return {
+            x,
+            y
+        };
+    }
+    protected matchesDeactivateGrid(event: KeyboardEvent): boolean {
+        return matchesKeystroke(event, 'Escape');
+    }
+    protected matchesGridBoxAtIndex(event: KeyboardEvent, index: number): boolean {
+        return matchesKeystroke(event, ('Digit' + index) as KeyCode) || matchesKeystroke(event, ('Numpad' + index) as KeyCode);
+    }
+    // https://www.delftstack.com/howto/javascript/get-position-of-element-in-javascript/
+    private getOffset(el: any): { top: number; left: number } {
+        let _x = 0;
+        let _y = 0;
+        while (el && !isNaN(el.offsetLeft) && !isNaN(el.offsetTop)) {
+            _x += el.offsetLeft - el.scrollLeft;
+            _y += el.offsetTop - el.scrollTop;
+            el = el.offsetParent;
+        }
+        return { top: _y, left: _x };
+    }
+
+    private getCenterOfCell(cell: HTMLElement): number[] {
+        const cellLeft = this.getOffset(cell).left;
+        const cellTop = this.getOffset(cell).top;
+        const cellWidth = cell.offsetWidth;
+        const cellHeight = cell.offsetHeight;
+
+        const newCellWidth = cellWidth / 2;
+        const newCellHeight = cellHeight / 2;
+
+        return [cellLeft + newCellWidth, cellTop + newCellHeight];
+    }
+}

package/src/features/accessibility/keyboard-grid/keyboard-node-grid.ts

@@ -0,0 +1,63 @@
+/********************************************************************************
+ * 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 '../../../../css/keyboard.css';
+
+import { inject, injectable } from 'inversify';
+import { ICommand, SetUIExtensionVisibilityAction, Action } from '@eclipse-glsp/sprotty';
+import { matchesKeystroke } from 'sprotty/lib/utils/keyboard';
+import { KeyboardPointer } from '../keyboard-pointer/keyboard-pointer';
+import { KeyboardPointerMetadata } from '../keyboard-pointer/constants';
+import { GridSearchPaletteMetadata } from './keyboard-grid-search-palette';
+import { KeyboardGrid } from './keyboard-grid';
+import { KeyboardNodeGridMetadata } from './constants';
+
+@injectable()
+export class KeyboardNodeGrid extends KeyboardGrid {
+    @inject(KeyboardPointer) protected readonly keyboardPointer: KeyboardPointer;
+
+    protected override triggerActions = [SetUIExtensionVisibilityAction.create({ extensionId: KeyboardPointerMetadata.ID, visible: true })];
+    protected override originId = KeyboardPointerMetadata.ID;
+
+    override id(): string {
+        return KeyboardNodeGridMetadata.ID;
+    }
+
+    override handle(action: Action): void | Action | ICommand {
+        // Do nothing
+    }
+
+    protected override onKeyDown(event: KeyboardEvent): void {
+        super.onKeyDown(event);
+        this.showSearchOnEvent(event);
+
+        if (this.keyboardPointer.isVisible) {
+            this.keyboardPointer.getKeyListener.keyDown(event);
+        }
+    }
+
+    protected showSearchOnEvent(event: KeyboardEvent): void {
+        if (matchesKeystroke(event, 'KeyF', 'ctrl')) {
+            event.preventDefault();
+            this.actionDispatcher.dispatch(
+                SetUIExtensionVisibilityAction.create({
+                    extensionId: GridSearchPaletteMetadata.ID,
+                    visible: true
+                })
+            );
+            this.hide();
+        }
+    }
+}