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

package/src/features/accessibility/edge-autocomplete/edge-autocomplete-tool.ts

@@ -0,0 +1,56 @@
+/********************************************************************************
+ * 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 { KeyTool, KeyListener, SetUIExtensionVisibilityAction, GModelElement, Action } from '@eclipse-glsp/sprotty';
+import { Tool } from '../../../base/tool-manager/tool';
+import { matchesKeystroke } from 'sprotty/lib/utils/keyboard';
+import { EdgeAutocompletePaletteMetadata } from './edge-autocomplete-palette';
+
+@injectable()
+export class EdgeAutocompletePaletteTool implements Tool {
+    static readonly ID = 'glsp.edge-autocomplete-palette-tool';
+
+    protected readonly keyListener = new EdgeAutocompletePaletteKeyListener();
+
+    @inject(KeyTool) protected keyTool: KeyTool;
+
+    get id(): string {
+        return EdgeAutocompletePaletteTool.ID;
+    }
+
+    enable(): void {
+        this.keyTool.register(this.keyListener);
+    }
+
+    disable(): void {
+        this.keyTool.deregister(this.keyListener);
+    }
+}
+
+export class EdgeAutocompletePaletteKeyListener extends KeyListener {
+    override keyDown(element: GModelElement, event: KeyboardEvent): Action[] {
+        if (matchesKeystroke(event, 'Escape')) {
+            return [
+                SetUIExtensionVisibilityAction.create({
+                    extensionId: EdgeAutocompletePaletteMetadata.ID,
+                    visible: false,
+                    contextElementsId: []
+                })
+            ];
+        }
+        return [];
+    }
+}

package/src/features/accessibility/element-navigation/diagram-navigation-tool.ts

@@ -0,0 +1,307 @@
+/********************************************************************************
+ * 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,
+    GModelElement,
+    GModelRoot,
+    KeyListener,
+    KeyTool,
+    SelectAction,
+    Selectable,
+    TYPES,
+    findParentByFeature,
+    isBoundsAware,
+    isSelectable,
+    isSelected
+} from '@eclipse-glsp/sprotty';
+import { inject, injectable } from 'inversify';
+import { toArray } from 'sprotty/lib/utils/iterable';
+import { matchesKeystroke } from 'sprotty/lib/utils/keyboard';
+import { GLSPActionDispatcher } from '../../../base/action-dispatcher';
+import { EnableDefaultToolsAction, EnableToolsAction, Tool } from '../../../base/tool-manager/tool';
+import { SelectableBoundsAware } from '../../../utils/gmodel-util';
+import { RepositionAction } from '../../viewport/reposition';
+import { SetAccessibleKeyShortcutAction } from '../key-shortcut/accessible-key-shortcut';
+import { AccessibleKeyShortcutTool } from '../key-shortcut/accessible-key-shortcut-tool';
+import { SearchAutocompletePaletteTool } from '../search/search-tool';
+import * as messages from '../toast/messages.json';
+import { ShowToastMessageAction } from '../toast/toast-handler';
+import { ElementNavigator } from './element-navigator';
+import { GEdge } from '../../../model';
+
+@injectable()
+export class ElementNavigatorTool implements Tool {
+    static ID = 'glsp.diagram-navigation';
+
+    isEditTool = false;
+
+    protected elementNavigatorKeyListener: ElementNavigatorKeyListener = new ElementNavigatorKeyListener(this);
+    @inject(KeyTool) protected readonly keytool: KeyTool;
+    @inject(TYPES.IElementNavigator) readonly elementNavigator: ElementNavigator;
+    @inject(TYPES.ILocalElementNavigator) readonly localElementNavigator: ElementNavigator;
+    @inject(TYPES.IActionDispatcher) readonly actionDispatcher: GLSPActionDispatcher;
+
+    get id(): string {
+        return ElementNavigatorTool.ID;
+    }
+
+    enable(): void {
+        this.keytool.register(this.elementNavigatorKeyListener);
+        this.elementNavigatorKeyListener.registerShortcutKey();
+    }
+
+    disable(): void {
+        this.keytool.deregister(this.elementNavigatorKeyListener);
+    }
+}
+
+enum NavigationMode {
+    POSITION = 'position',
+    DEFAULT = 'default',
+    NONE = 'none'
+}
+
+export class ElementNavigatorKeyListener extends KeyListener {
+    protected mode = NavigationMode.NONE;
+    protected previousNode?: SelectableBoundsAware;
+    protected navigator?: ElementNavigator;
+    protected readonly token = ElementNavigatorKeyListener.name;
+
+    constructor(protected readonly tool: ElementNavigatorTool) {
+        super();
+    }
+
+    registerShortcutKey(): void {
+        this.tool.actionDispatcher.dispatchOnceModelInitialized(
+            SetAccessibleKeyShortcutAction.create({
+                token: this.token,
+                keys: [
+                    { shortcuts: ['N'], description: 'Activate default navigation', group: 'Navigation', position: 0 },
+                    {
+                        shortcuts: ['ALT', 'N'],
+                        description: 'Activate position based navigation',
+                        group: 'Navigation',
+                        position: 1
+                    },
+                    {
+                        shortcuts: ['⬅  ⬆  ➡  ⬇'],
+                        description: 'Navigate by relation or neighbors according to navigation mode',
+                        group: 'Navigation',
+                        position: 2
+                    }
+                ]
+            })
+        );
+    }
+
+    override keyDown(element: GModelElement, event: KeyboardEvent): Action[] {
+        this.resetOnEscape(event, element);
+
+        if (this.getSelectedElements(element.root).length > 0) {
+            if (!this.triggerPositionNavigationOnEvent(event, element)) {
+                this.triggerDefaultNavigationOnEvent(event, element);
+            }
+
+            return this.navigate(element, event);
+        }
+
+        this.resetPositionNavigationOnEvent(event, element);
+        this.resetDefaultNavigationOnEvent(event, element);
+
+        return [];
+    }
+    protected resetOnEscape(event: KeyboardEvent, element: GModelElement): void {
+        if (this.mode !== NavigationMode.NONE && this.matchesDeactivateNavigationMode(event)) {
+            this.navigator?.clean?.(element.root);
+            this.clean();
+
+            if (this.mode === NavigationMode.POSITION) {
+                this.tool.actionDispatcher.dispatchAll([
+                    EnableDefaultToolsAction.create(),
+                    ShowToastMessageAction.createWithTimeout({
+                        id: Symbol.for(ElementNavigatorKeyListener.name),
+                        message: messages.navigation.local_navigation_mode_deactivated
+                    })
+                ]);
+            } else if (this.mode === NavigationMode.DEFAULT) {
+                this.tool.actionDispatcher.dispatchAll([
+                    EnableDefaultToolsAction.create(),
+                    ShowToastMessageAction.createWithTimeout({
+                        id: Symbol.for(ElementNavigatorKeyListener.name),
+                        message: messages.navigation.default_navigation_mode_deactivated
+                    })
+                ]);
+            }
+
+            this.mode = NavigationMode.NONE;
+        }
+    }
+
+    protected triggerPositionNavigationOnEvent(event: KeyboardEvent, element: GModelElement): boolean {
+        if (this.matchesActivatePositionNavigation(event)) {
+            if (this.mode !== NavigationMode.POSITION) {
+                this.clean();
+                this.tool.actionDispatcher.dispatchAll([
+                    EnableToolsAction.create([ElementNavigatorTool.ID, SearchAutocompletePaletteTool.ID, AccessibleKeyShortcutTool.ID]),
+                    ShowToastMessageAction.create({
+                        id: Symbol.for(ElementNavigatorKeyListener.name),
+                        message: messages.navigation.local_navigation_mode_activated
+                    })
+                ]);
+                this.navigator = this.tool.elementNavigator;
+                this.mode = NavigationMode.POSITION;
+            } else {
+                this.resetPositionNavigationOnEvent(event, element);
+            }
+
+            return true;
+        }
+
+        return false;
+    }
+
+    protected resetPositionNavigationOnEvent(event: KeyboardEvent, element: GModelElement): void {
+        if (this.mode === NavigationMode.POSITION && this.matchesActivatePositionNavigation(event)) {
+            this.navigator?.clean?.(element.root);
+            this.clean();
+            this.mode = NavigationMode.NONE;
+            this.tool.actionDispatcher.dispatchAll([
+                EnableDefaultToolsAction.create(),
+                ShowToastMessageAction.createWithTimeout({
+                    id: Symbol.for(ElementNavigatorKeyListener.name),
+                    message: messages.navigation.local_navigation_mode_deactivated
+                })
+            ]);
+        }
+    }
+    protected triggerDefaultNavigationOnEvent(event: KeyboardEvent, element: GModelElement): boolean {
+        if (this.matchesActivateDefaultNavigation(event)) {
+            if (this.mode !== NavigationMode.DEFAULT) {
+                this.clean();
+
+                this.tool.actionDispatcher.dispatchAll([
+                    EnableToolsAction.create([ElementNavigatorTool.ID, SearchAutocompletePaletteTool.ID, AccessibleKeyShortcutTool.ID]),
+                    ShowToastMessageAction.create({
+                        id: Symbol.for(ElementNavigatorKeyListener.name),
+                        message: messages.navigation.default_navigation_mode_activated
+                    })
+                ]);
+                this.navigator = this.tool.localElementNavigator;
+                this.mode = NavigationMode.DEFAULT;
+            } else {
+                this.resetDefaultNavigationOnEvent(event, element);
+            }
+
+            return true;
+        }
+        return false;
+    }
+
+    protected resetDefaultNavigationOnEvent(event: KeyboardEvent, element: GModelElement): void {
+        if (this.mode === NavigationMode.DEFAULT && this.matchesActivateDefaultNavigation(event)) {
+            this.navigator?.clean?.(element.root);
+            this.clean();
+            this.mode = NavigationMode.NONE;
+            this.tool.actionDispatcher.dispatchAll([
+                EnableDefaultToolsAction.create(),
+                ShowToastMessageAction.createWithTimeout({
+                    id: Symbol.for(ElementNavigatorKeyListener.name),
+                    message: messages.navigation.default_navigation_mode_deactivated
+                })
+            ]);
+        }
+    }
+
+    protected navigate(element: GModelElement, event: KeyboardEvent): Action[] {
+        const selected = this.getSelectedElements(element.root);
+        const current = selected.length > 0 ? selected[0] : undefined;
+
+        if (this.mode !== NavigationMode.NONE && this.navigator !== undefined && current !== undefined && isBoundsAware(current)) {
+            this.navigator.clean?.(current.root, current, this.previousNode);
+
+            const target = this.navigateOnEvent(event, this.navigator, current);
+
+            if (target !== undefined) {
+                this.navigator.process?.(current.root, current, target as SelectableBoundsAware, this.previousNode);
+            }
+            const selectableTarget = target ? findParentByFeature(target, isSelectable) : undefined;
+
+            if (selectableTarget) {
+                if (!(current instanceof GEdge)) {
+                    this.previousNode = current;
+                }
+                const deselectedElementsIDs = selected.map(e => e.id).filter(id => id !== selectableTarget.id);
+
+                return [
+                    SelectAction.create({ selectedElementsIDs: [selectableTarget.id], deselectedElementsIDs }),
+                    RepositionAction.create([selectableTarget.id])
+                ];
+            }
+        }
+
+        return [];
+    }
+
+    protected navigateOnEvent(
+        event: KeyboardEvent,
+        navigator: ElementNavigator,
+        current: SelectableBoundsAware
+    ): GModelElement | undefined {
+        if (this.matchesNavigatePrevious(event)) {
+            return navigator.previous(current.root, current);
+        } else if (this.matchesNavigateNext(event)) {
+            return navigator.next(current.root, current);
+        } else if (this.matchesNavigateUp(event)) {
+            return navigator.up?.(current.root, current, this.previousNode);
+        } else if (this.matchesNavigateDown(event)) {
+            return navigator.down?.(current.root, current, this.previousNode);
+        }
+
+        return undefined;
+    }
+
+    protected clean(): void {
+        this.previousNode = undefined;
+        this.navigator = undefined;
+    }
+
+    protected getSelectedElements(root: GModelRoot): (GModelElement & Selectable)[] {
+        return toArray(root.index.all().filter(e => isSelected(e))) as (GModelElement & Selectable)[];
+    }
+
+    protected matchesDeactivateNavigationMode(event: KeyboardEvent): boolean {
+        return matchesKeystroke(event, 'Escape');
+    }
+    protected matchesActivateDefaultNavigation(event: KeyboardEvent): boolean {
+        return matchesKeystroke(event, 'KeyN');
+    }
+    protected matchesActivatePositionNavigation(event: KeyboardEvent): boolean {
+        return matchesKeystroke(event, 'KeyN', 'alt');
+    }
+    protected matchesNavigatePrevious(event: KeyboardEvent): boolean {
+        return matchesKeystroke(event, 'ArrowLeft');
+    }
+    protected matchesNavigateNext(event: KeyboardEvent): boolean {
+        return matchesKeystroke(event, 'ArrowRight');
+    }
+    protected matchesNavigateUp(event: KeyboardEvent): boolean {
+        return matchesKeystroke(event, 'ArrowUp');
+    }
+    protected matchesNavigateDown(event: KeyboardEvent): boolean {
+        return matchesKeystroke(event, 'ArrowDown');
+    }
+}

package/src/features/accessibility/element-navigation/element-navigation-module.ts

@@ -0,0 +1,36 @@
+/********************************************************************************
+ * 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 { BindingContext, TYPES, bindAsService } from '@eclipse-glsp/sprotty';
+import { PositionNavigator } from './position-navigator';
+import { LocalElementNavigator } from './local-element-navigator';
+import { ElementNavigatorTool } from './diagram-navigation-tool';
+import '../../../../css/navigation.css';
+
+/**
+ * Handles element navigation actions.
+ */
+
+export const glspElementNavigationModule = new ContainerModule((bind, unbind, isBound, rebind) => {
+    const context = { bind, unbind, isBound, rebind };
+    configureElementNavigationTool(context);
+});
+
+export function configureElementNavigationTool(context: BindingContext): void {
+    bindAsService(context, TYPES.IDefaultTool, ElementNavigatorTool);
+    bindAsService(context, TYPES.IElementNavigator, PositionNavigator);
+    bindAsService(context, TYPES.ILocalElementNavigator, LocalElementNavigator);
+}

package/src/features/accessibility/element-navigation/element-navigator.ts

@@ -0,0 +1,57 @@
+/********************************************************************************
+ * 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 { GModelElement, GModelRoot } from '@eclipse-glsp/sprotty';
+import { SelectableBoundsAware } from '../../../utils/gmodel-util';
+
+export interface ElementNavigator {
+    previous(
+        root: Readonly<GModelRoot>,
+        current: SelectableBoundsAware,
+        previousCurrent?: SelectableBoundsAware,
+        predicate?: (element: GModelElement) => boolean
+    ): GModelElement | undefined;
+
+    next(
+        root: Readonly<GModelRoot>,
+        current: SelectableBoundsAware,
+        previousCurrent?: SelectableBoundsAware,
+        predicate?: (element: GModelElement) => boolean
+    ): GModelElement | undefined;
+
+    up?(
+        root: Readonly<GModelRoot>,
+        current: SelectableBoundsAware,
+        previousCurrent?: SelectableBoundsAware,
+        predicate?: (element: GModelElement) => boolean
+    ): GModelElement | undefined;
+
+    down?(
+        root: Readonly<GModelRoot>,
+        current: SelectableBoundsAware,
+        previousCurrent?: SelectableBoundsAware,
+        predicate?: (element: GModelElement) => boolean
+    ): GModelElement | undefined;
+
+    process?(
+        root: Readonly<GModelRoot>,
+        current: SelectableBoundsAware,
+        target: SelectableBoundsAware,
+        previousCurrent?: SelectableBoundsAware,
+        predicate?: (element: GModelElement) => boolean
+    ): void;
+    clean?(root: Readonly<GModelRoot>, current?: SelectableBoundsAware, previousCurrent?: SelectableBoundsAware): void;
+}

package/src/features/accessibility/element-navigation/left-right-top-bottom-navigator.ts

@@ -0,0 +1,114 @@
+/********************************************************************************
+ * 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 { EdgeRouterRegistry, findParentByFeature, GModelElement, GModelRoot, Point } from '@eclipse-glsp/sprotty';
+import { inject, injectable, optional } from 'inversify';
+import { toArray } from 'sprotty/lib/utils/iterable';
+import { calcElementAndRoute, isRoutable, isSelectableAndBoundsAware, SelectableBoundsAware } from '../../../utils/gmodel-util';
+import { ElementNavigator } from './element-navigator';
+import { GEdge } from '../../../model';
+
+@injectable()
+export class LeftToRightTopToBottomElementNavigator implements ElementNavigator {
+    @inject(EdgeRouterRegistry) @optional() readonly edgeRouterRegistry?: EdgeRouterRegistry;
+
+    previous(
+        root: Readonly<GModelRoot>,
+        current?: SelectableBoundsAware,
+        previousCurrent?: SelectableBoundsAware,
+        predicate: (element: GModelElement) => boolean = () => true
+    ): GModelElement | undefined {
+        const elements = this.getElements(root, predicate);
+
+        if (current === undefined) {
+            return elements.length > 0 ? elements[0] : undefined;
+        }
+        return elements[this.getPreviousIndex(current, elements) % elements.length];
+    }
+
+    next(
+        root: Readonly<GModelRoot>,
+        current?: SelectableBoundsAware,
+        previousCurrent?: SelectableBoundsAware,
+        predicate: (element: GModelElement) => boolean = () => true
+    ): GModelElement | undefined {
+        const elements = this.getElements(root, predicate);
+        if (current === undefined) {
+            return elements.length > 0 ? elements[0] : undefined;
+        }
+        return elements[this.getNextIndex(current, elements) % elements.length];
+    }
+
+    protected getElements(root: Readonly<GModelRoot>, predicate: (element: GModelElement) => boolean): GModelElement[] {
+        const elements = toArray(root.index.all().filter(e => isSelectableAndBoundsAware(e))) as SelectableBoundsAware[];
+        return elements.sort((a, b) => this.compare(a, b)).filter(predicate);
+    }
+
+    protected getNextIndex(current: SelectableBoundsAware, elements: GModelElement[]): number {
+        for (let index = 0; index < elements.length; index++) {
+            if (this.compare(elements[index], current) > 0) {
+                return index;
+            }
+        }
+
+        return 0;
+    }
+
+    protected getPreviousIndex(current: SelectableBoundsAware, elements: GModelElement[]): number {
+        for (let index = elements.length - 1; index >= 0; index--) {
+            if (this.compare(elements[index], current) < 0) {
+                return index;
+            }
+        }
+
+        return elements.length - 1;
+    }
+
+    protected compare(one: GModelElement, other: GModelElement): number {
+        let positionOne: Point | undefined = undefined;
+        let positionOther: Point | undefined = undefined;
+
+        if (one instanceof GEdge && isRoutable(one)) {
+            positionOne = calcElementAndRoute(one, this.edgeRouterRegistry).newRoutingPoints?.[0];
+        }
+
+        if (other instanceof GEdge && isRoutable(other)) {
+            positionOther = calcElementAndRoute(other, this.edgeRouterRegistry).newRoutingPoints?.[0];
+        }
+
+        const boundsOne = findParentByFeature(one, isSelectableAndBoundsAware);
+        const boundsOther = findParentByFeature(other, isSelectableAndBoundsAware);
+
+        if (positionOne === undefined && boundsOne) {
+            positionOne = boundsOne.bounds;
+        }
+
+        if (positionOther === undefined && boundsOther) {
+            positionOther = boundsOther.bounds;
+        }
+
+        if (positionOne && positionOther) {
+            if (positionOne.y !== positionOther.y) {
+                return positionOne.y - positionOther.y;
+            }
+            if (positionOne.x !== positionOther.x) {
+                return positionOne.x - positionOther.x;
+            }
+        }
+
+        return 0;
+    }
+}