@eclipse-glsp/client 1.1.0-next.fdfeeeb.193 → 2.1.0-next.12ca798.289

package/src/features/accessibility/keyboard-pointer/actions.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 { Action, hasNumberProp } from '@eclipse-glsp/sprotty';
+
+export interface SetKeyboardPointerRenderPositionAction extends Action {
+    kind: typeof SetKeyboardPointerRenderPositionAction.KIND;
+    x: number;
+    y: number;
+}
+
+export namespace SetKeyboardPointerRenderPositionAction {
+    export const KIND = 'setKeyboardPointerRenderPositionAction';
+
+    export function is(object: any): object is SetKeyboardPointerRenderPositionAction {
+        return Action.hasKind(object, KIND) && hasNumberProp(object, 'x') && hasNumberProp(object, 'y');
+    }
+
+    export function create(x: number, y: number): SetKeyboardPointerRenderPositionAction {
+        return { kind: KIND, x, y };
+    }
+}

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

@@ -0,0 +1,22 @@
+/********************************************************************************
+ * 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 KeyboardPointerMetadata {
+    export const ID = 'keyboard-pointer';
+    export const CRICLE_HEIGHT = 16;
+    export const CIRCLE_WIDTH = 16;
+    export const TAB_INDEX = 10;
+}

package/src/features/accessibility/keyboard-pointer/keyboard-pointer-listener.ts

@@ -0,0 +1,125 @@
+/********************************************************************************
+ * 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 { IActionDispatcher, SetUIExtensionVisibilityAction, CreateNodeOperation } from '@eclipse-glsp/sprotty';
+import { matchesKeystroke } from 'sprotty/lib/utils/keyboard';
+import { KeyboardNodeGridMetadata } from '../keyboard-grid/constants';
+import { KeyboardPointerMetadata } from './constants';
+import { KeyboardPointer } from './keyboard-pointer';
+import { KeyboardPointerPosition } from './keyboard-pointer-position';
+import { EnableDefaultToolsAction } from '../../../base/tool-manager/tool';
+import { CursorCSS } from '../../../base/feedback/css-feedback';
+
+/**
+ * Keyboard listener for the pointer with the necessary logic to handle keyboard events
+ */
+export class KeyboardPointerKeyboardListener {
+    protected get position(): KeyboardPointerPosition {
+        return this.keyboardPointer.getPosition;
+    }
+
+    constructor(protected readonly keyboardPointer: KeyboardPointer, protected readonly actionDispatcher: IActionDispatcher) {}
+
+    keyDown(event: KeyboardEvent): void {
+        this.moveIfArrows(event);
+        this.createIfEnterEvent(event);
+        this.hideIfEscapeEvent(event);
+    }
+
+    protected moveIfArrows(event: KeyboardEvent): any {
+        if (this.matchesMovePointerDown(event)) {
+            this.position.renderPosition = this.position.calcRelativeRenderPosition(0, 10);
+            this.keyboardPointer.render();
+        } else if (this.matchesMovePointerUp(event)) {
+            this.position.renderPosition = this.position.calcRelativeRenderPosition(0, -10);
+            this.keyboardPointer.render();
+        } else if (this.matchesMovePointerRight(event)) {
+            this.position.renderPosition = this.position.calcRelativeRenderPosition(10, 0);
+            this.keyboardPointer.render();
+        } else if (this.matchesMovePointerLeft(event)) {
+            this.position.renderPosition = this.position.calcRelativeRenderPosition(-10, 0);
+            this.keyboardPointer.render();
+        }
+    }
+
+    protected createIfEnterEvent(event: KeyboardEvent): any {
+        const elementTypeId = this.keyboardPointer.triggerAction.elementTypeId;
+
+        const { container, status } = this.position.containableParentAtDiagramPosition(elementTypeId);
+
+        if (container !== undefined && status === CursorCSS.NODE_CREATION) {
+            if (this.matchesConfirmPointerPosition(event)) {
+                // close everything and return to default
+
+                const containerId = container.id;
+                const location = this.position.diagramPosition;
+
+                this.actionDispatcher.dispatchAll([
+                    SetUIExtensionVisibilityAction.create({
+                        extensionId: KeyboardPointerMetadata.ID,
+                        visible: false,
+                        contextElementsId: []
+                    }),
+                    SetUIExtensionVisibilityAction.create({
+                        extensionId: KeyboardNodeGridMetadata.ID,
+                        visible: false,
+                        contextElementsId: []
+                    }),
+                    CreateNodeOperation.create(elementTypeId, { location, containerId, args: this.keyboardPointer.triggerAction.args }),
+                    EnableDefaultToolsAction.create()
+                ]);
+            } else if (this.matchesConfirmPointerPositionAndStayInMode(event)) {
+                // stay in this mode, selected palette option stays, grid and keyboard mouse are displayed
+
+                const containerId = container.id;
+                const location = this.position.diagramPosition;
+
+                this.actionDispatcher.dispatch(
+                    CreateNodeOperation.create(elementTypeId, { location, containerId, args: this.keyboardPointer.triggerAction.args })
+                );
+            }
+        }
+    }
+
+    protected hideIfEscapeEvent(event: KeyboardEvent): any {
+        if (this.matchesDeactivatePointer(event)) {
+            this.keyboardPointer.hide();
+        }
+    }
+
+    protected matchesDeactivatePointer(event: KeyboardEvent): boolean {
+        return matchesKeystroke(event, 'Escape');
+    }
+    protected matchesConfirmPointerPosition(event: KeyboardEvent): boolean {
+        return matchesKeystroke(event, 'Enter');
+    }
+    protected matchesConfirmPointerPositionAndStayInMode(event: KeyboardEvent): boolean {
+        return matchesKeystroke(event, 'Enter', 'ctrl');
+    }
+
+    protected matchesMovePointerLeft(event: KeyboardEvent): boolean {
+        return matchesKeystroke(event, 'ArrowLeft');
+    }
+    protected matchesMovePointerRight(event: KeyboardEvent): boolean {
+        return matchesKeystroke(event, 'ArrowRight');
+    }
+    protected matchesMovePointerUp(event: KeyboardEvent): boolean {
+        return matchesKeystroke(event, 'ArrowUp');
+    }
+    protected matchesMovePointerDown(event: KeyboardEvent): boolean {
+        return matchesKeystroke(event, 'ArrowDown');
+    }
+}

package/src/features/accessibility/keyboard-pointer/keyboard-pointer-module.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 {
+    TYPES,
+    bindAsService,
+    configureActionHandler,
+    TriggerNodeCreationAction,
+    FeatureModule,
+    BindingContext,
+    TriggerEdgeCreationAction
+} from '@eclipse-glsp/sprotty';
+import { GlobalKeyListenerTool } from '../global-keylistener-tool';
+import { KeyboardPointer } from './keyboard-pointer';
+import { KeyboardGrid } from '../keyboard-grid/keyboard-grid';
+import { SetKeyboardPointerRenderPositionAction } from './actions';
+import { EdgeAutocompletePalette } from '../edge-autocomplete/edge-autocomplete-palette';
+import { EdgeAutocompletePaletteTool } from '../edge-autocomplete/edge-autocomplete-tool';
+import { SetEdgeTargetSelectionAction } from '../edge-autocomplete/action';
+import { GridSearchPalette } from '../keyboard-grid/keyboard-grid-search-palette';
+import { KeyboardNodeGrid } from '../keyboard-grid/keyboard-node-grid';
+import { EnableKeyboardGridAction, KeyboardGridCellSelectedAction } from '../keyboard-grid/action';
+
+/**
+ * Handles the pointer used via grid to position new elements.
+ */
+export const keyboardControlModule = new FeatureModule((bind, unbind, isBound, rebind) => {
+    const context = { bind, unbind, isBound, rebind };
+    configureKeyboardControlTools(context);
+});
+
+export function configureKeyboardControlTools(context: BindingContext): void {
+    bindAsService(context, TYPES.IDefaultTool, GlobalKeyListenerTool);
+    bindAsService(context, TYPES.IUIExtension, KeyboardPointer);
+    bindAsService(context, TYPES.IUIExtension, KeyboardGrid);
+    bindAsService(context, TYPES.IUIExtension, KeyboardNodeGrid);
+
+    configureActionHandler(context, TriggerNodeCreationAction.KIND, KeyboardPointer);
+    configureActionHandler(context, SetKeyboardPointerRenderPositionAction.KIND, KeyboardPointer);
+
+    bindAsService(context, TYPES.IUIExtension, EdgeAutocompletePalette);
+    bindAsService(context, TYPES.IDefaultTool, EdgeAutocompletePaletteTool);
+
+    configureActionHandler(context, EnableKeyboardGridAction.KIND, KeyboardGrid);
+    configureActionHandler(context, KeyboardGridCellSelectedAction.KIND, KeyboardPointer);
+
+    configureActionHandler(context, TriggerEdgeCreationAction.KIND, EdgeAutocompletePalette);
+    configureActionHandler(context, SetEdgeTargetSelectionAction.KIND, EdgeAutocompletePalette);
+
+    bindAsService(context, TYPES.IUIExtension, GridSearchPalette);
+}

package/src/features/accessibility/keyboard-pointer/keyboard-pointer-position.ts

@@ -0,0 +1,78 @@
+/********************************************************************************
+ * 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 { findChildrenAtPosition, findParentByFeature, GModelElement, Point } from '@eclipse-glsp/sprotty';
+import { Containable, isContainable } from '../../hints/model';
+import { getAbsolutePositionByPoint } from '../../../utils/viewpoint-util';
+import { KeyboardPointerMetadata } from './constants';
+import { KeyboardPointer } from './keyboard-pointer';
+import { CursorCSS } from '../../../base/feedback/css-feedback';
+
+export class KeyboardPointerPosition {
+    public renderPosition: Point = { x: 20, y: 20 };
+
+    constructor(protected readonly keyboardPointer: KeyboardPointer) {}
+
+    get centerizedRenderPosition(): Point {
+        return {
+            x: this.renderPosition.x + KeyboardPointerMetadata.CIRCLE_WIDTH / 2,
+            y: this.renderPosition.y + KeyboardPointerMetadata.CRICLE_HEIGHT / 2
+        };
+    }
+
+    get diagramPosition(): Point {
+        return getAbsolutePositionByPoint(this.keyboardPointer.editorContextService.modelRoot, this.centerizedRenderPosition);
+    }
+
+    childrenAtDiagramPosition(): GModelElement[] {
+        const position = this.diagramPosition;
+
+        return [
+            this.keyboardPointer.editorContextService.modelRoot,
+            ...findChildrenAtPosition(this.keyboardPointer.editorContextService.modelRoot, position)
+        ];
+    }
+
+    containableParentAtDiagramPosition(elementTypeId: string): {
+        container: (GModelElement & Containable) | undefined;
+        status: CursorCSS;
+    } {
+        const children = this.childrenAtDiagramPosition();
+
+        return this.containableParentOf(children.reverse()[0], elementTypeId);
+    }
+
+    calcRelativeRenderPosition(x: number, y: number): Point {
+        return {
+            x: this.renderPosition.x + x,
+            y: this.renderPosition.y + y
+        };
+    }
+
+    private containableParentOf(
+        target: GModelElement,
+        elementTypeId: string
+    ): { container: (GModelElement & Containable) | undefined; status: CursorCSS } {
+        const container = findParentByFeature(target, isContainable);
+        return {
+            container,
+            status: this.isCreationAllowed(container, elementTypeId) ? CursorCSS.NODE_CREATION : CursorCSS.OPERATION_NOT_ALLOWED
+        };
+    }
+
+    private isCreationAllowed(container: (GModelElement & Containable) | undefined, elementTypeId: string): boolean | undefined {
+        return container && container.isContainableElement(elementTypeId);
+    }
+}

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

@@ -0,0 +1,120 @@
+/********************************************************************************
+ * 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 {
+    AbstractUIExtension,
+    IActionDispatcher,
+    IActionHandler,
+    GModelRoot,
+    TYPES,
+    Action,
+    TriggerNodeCreationAction
+} from '@eclipse-glsp/sprotty';
+import { SetKeyboardPointerRenderPositionAction } from './actions';
+import { KeyboardPointerMetadata } from './constants';
+import { KeyboardPointerKeyboardListener } from './keyboard-pointer-listener';
+import { KeyboardPointerPosition } from './keyboard-pointer-position';
+import { KeyboardGridCellSelectedAction } from '../keyboard-grid/action';
+import { EditorContextService } from '../../../base/editor-context-service';
+import { CursorCSS } from '../../../base/feedback/css-feedback';
+
+@injectable()
+export class KeyboardPointer extends AbstractUIExtension implements IActionHandler {
+    protected _triggerAction: TriggerNodeCreationAction = {
+        elementTypeId: 'task:automated',
+        kind: 'triggerNodeCreation'
+    };
+
+    protected position: KeyboardPointerPosition = new KeyboardPointerPosition(this);
+    protected keyListener: KeyboardPointerKeyboardListener;
+    @inject(EditorContextService)
+    public editorContextService: EditorContextService;
+
+    constructor(@inject(TYPES.IActionDispatcher) protected readonly actionDispatcher: IActionDispatcher) {
+        super();
+
+        this.keyListener = new KeyboardPointerKeyboardListener(this, actionDispatcher);
+    }
+
+    get triggerAction(): TriggerNodeCreationAction {
+        return this._triggerAction;
+    }
+
+    get isVisible(): boolean {
+        return this.containerElement?.style.visibility === 'visible';
+    }
+
+    get getPosition(): KeyboardPointerPosition {
+        return this.position;
+    }
+    get getKeyListener(): KeyboardPointerKeyboardListener {
+        return this.keyListener;
+    }
+
+    id(): string {
+        return KeyboardPointerMetadata.ID;
+    }
+
+    containerClass(): string {
+        return KeyboardPointerMetadata.ID;
+    }
+
+    protected initializeContents(containerElement: HTMLElement): void {
+        containerElement.style.position = 'absolute';
+        containerElement.style.height = `${KeyboardPointerMetadata.CRICLE_HEIGHT}px`;
+        containerElement.style.width = `${KeyboardPointerMetadata.CIRCLE_WIDTH}px`;
+        containerElement.style.borderRadius = '100%';
+    }
+
+    protected override onBeforeShow(containerElement: HTMLElement, root: Readonly<GModelRoot>, ...selectedElementIds: string[]): void {
+        this.render();
+    }
+
+    handle(action: Action): Action | void {
+        if (TriggerNodeCreationAction.is(action)) {
+            this._triggerAction = action;
+        } else if (SetKeyboardPointerRenderPositionAction.is(action)) {
+            this.position.renderPosition = { x: action.x, y: action.y };
+            this.render();
+        } else if (KeyboardGridCellSelectedAction.is(action) && action.options.originId === KeyboardPointerMetadata.ID) {
+            this.position.renderPosition = action.options.centerCellPosition;
+            this.render();
+        }
+    }
+
+    render(): void {
+        if (this.containerElement !== undefined) {
+            const { x, y } = this.position.renderPosition;
+            this.containerElement.style.left = `${x}px`;
+            this.containerElement.style.top = `${y}px`;
+
+            const { status } = this.position.containableParentAtDiagramPosition(this._triggerAction.elementTypeId);
+
+            this.containerElement.style.borderStyle = 'solid';
+            this.containerElement.style.borderWidth = 'thick';
+            switch (status) {
+                case CursorCSS.NODE_CREATION: {
+                    this.containerElement.style.borderColor = 'green';
+                    break;
+                }
+                case CursorCSS.OPERATION_NOT_ALLOWED: {
+                    this.containerElement.style.borderColor = 'red';
+                    break;
+                }
+            }
+        }
+    }
+}

package/src/features/accessibility/keyboard-tool-palette/keyboard-tool-palette-module.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 '../../../../css/keyboard-tool-palette.css';
+
+import { configureActionHandler, TYPES, bindAsService, BindingContext, FeatureModule } from '@eclipse-glsp/sprotty';
+import { EnableToolPaletteAction } from '../../tool-palette/tool-palette';
+import { KeyboardToolPalette } from './keyboard-tool-palette';
+import { FocusDomAction } from '../actions';
+import { EnableDefaultToolsAction } from '../../../base/tool-manager/tool';
+
+export const keyboardToolPaletteModule = new FeatureModule((bind, unbind, isBound, rebind) => {
+    const context = { bind, unbind, isBound, rebind };
+    configureKeyboardToolPaletteTool(context);
+});
+
+export function configureKeyboardToolPaletteTool(context: BindingContext): void {
+    bindAsService(context, TYPES.IUIExtension, KeyboardToolPalette);
+    context.bind(TYPES.IDiagramStartup).toService(KeyboardToolPalette);
+    configureActionHandler(context, EnableDefaultToolsAction.KIND, KeyboardToolPalette);
+    configureActionHandler(context, FocusDomAction.KIND, KeyboardToolPalette);
+    configureActionHandler(context, EnableToolPaletteAction.KIND, KeyboardToolPalette);
+}