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

package/src/features/accessibility/move-zoom/move-handler.ts

@@ -0,0 +1,209 @@
+/********************************************************************************
+ * 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 { throttle } from 'lodash';
+import {
+    Action,
+    ChangeBoundsOperation,
+    IActionDispatcher,
+    IActionHandler,
+    ICommand,
+    Point,
+    GModelRoot,
+    SetViewportAction,
+    TYPES,
+    Viewport,
+    findParentByFeature,
+    isViewport
+} from '@eclipse-glsp/sprotty';
+import { EditorContextService } from '../../../base/editor-context-service';
+import { SelectableBoundsAware, getElements, isSelectableAndBoundsAware } from '../../../utils/gmodel-util';
+
+/**
+ * Action for triggering moving of the viewport.
+ */
+export interface MoveViewportAction extends Action {
+    kind: typeof MoveViewportAction.KIND;
+    /**
+     * used to specify the amount to be moved in the x-axis
+     */
+    moveX: number;
+    /**
+     * used to specify the amount to be moved in the y-axis
+     */
+    moveY: number;
+}
+
+export namespace MoveViewportAction {
+    export const KIND = 'moveViewportAction';
+
+    export function is(object: any): object is MoveViewportAction {
+        return Action.hasKind(object, KIND);
+    }
+
+    export function create(moveX: number, moveY: number): MoveViewportAction {
+        return { kind: KIND, moveX, moveY };
+    }
+}
+
+/**
+ * Action for triggering moving of elements.
+ */
+export interface MoveElementAction extends Action {
+    kind: typeof MoveElementAction.KIND;
+    /**
+     * used to specify the elements to be zoomed in/out
+     */
+    elementIds: string[];
+    /**
+     * used to specify the amount to be moved in the x-axis
+     */
+    moveX: number;
+    /**
+     * used to specify the amount to be moved in the y-axis
+     */
+    moveY: number;
+}
+
+export namespace MoveElementAction {
+    export const KIND = 'moveElementAction';
+
+    export function is(object: any): object is MoveElementAction {
+        return Action.hasKind(object, KIND);
+    }
+
+    export function create(elementIds: string[], moveX: number, moveY: number): MoveElementAction {
+        return { kind: KIND, elementIds, moveX, moveY };
+    }
+}
+
+/* The MoveViewportHandler class is an implementation of the IActionHandler interface that handles
+moving of the viewport. */
+@injectable()
+export class MoveViewportHandler implements IActionHandler {
+    @inject(EditorContextService)
+    protected editorContextService: EditorContextService;
+
+    @inject(TYPES.IActionDispatcher) protected dispatcher: IActionDispatcher;
+    protected readonly throttledHandleViewportMove = throttle((action: MoveViewportAction) => this.handleMoveViewport(action), 150);
+
+    handle(action: Action): void | Action | ICommand {
+        if (MoveViewportAction.is(action)) {
+            this.throttledHandleViewportMove(action);
+        }
+    }
+
+    handleMoveViewport(action: MoveViewportAction): void {
+        const viewport = findParentByFeature(this.editorContextService.modelRoot, isViewport);
+        if (!viewport) {
+            return;
+        }
+        this.dispatcher.dispatch(this.moveViewport(viewport, action.moveX, action.moveY));
+    }
+
+    protected moveViewport(viewport: GModelRoot & Viewport, offsetX: number, offSetY: number): SetViewportAction {
+        const newViewport: Viewport = {
+            scroll: {
+                x: viewport.scroll.x + offsetX,
+                y: viewport.scroll.y + offSetY
+            },
+            zoom: viewport.zoom
+        };
+
+        return SetViewportAction.create(viewport.id, newViewport, { animate: true });
+    }
+}
+
+/* The MoveElementHandler class is an implementation of the IActionHandler interface that handles
+moving elements. */
+@injectable()
+export class MoveElementHandler implements IActionHandler {
+    @inject(EditorContextService)
+    protected editorContextService: EditorContextService;
+    @inject(TYPES.IActionDispatcher) protected dispatcher: IActionDispatcher;
+    protected readonly throttledHandleElementMove = throttle((action: MoveElementAction) => this.handleMoveElement(action), 150);
+
+    handle(action: Action): void | Action | ICommand {
+        if (MoveElementAction.is(action)) {
+            this.throttledHandleElementMove(action);
+        }
+    }
+
+    handleMoveElement(action: MoveElementAction): void {
+        const viewport = findParentByFeature(this.editorContextService.modelRoot, isViewport);
+        if (!viewport) {
+            return;
+        }
+
+        const elements = getElements(this.editorContextService.modelRoot.index, action.elementIds, isSelectableAndBoundsAware);
+
+        this.dispatcher.dispatchAll(this.move(viewport, elements, action.moveX, action.moveY));
+    }
+
+    protected getBounds(element: SelectableBoundsAware, offSetX: number, offSetY: number): Point {
+        return { x: element.bounds.x + offSetX, y: element.bounds.y + offSetY };
+    }
+
+    protected adaptViewport(
+        viewport: GModelRoot & Viewport,
+        newPoint: Point,
+        moveX: number,
+        moveY: number
+    ): MoveViewportAction | undefined {
+        if (
+            newPoint.x < viewport.scroll.x ||
+            newPoint.x > viewport.scroll.x + viewport.canvasBounds.width ||
+            newPoint.y < viewport.scroll.y ||
+            newPoint.y > viewport.scroll.y + viewport.canvasBounds.height
+        ) {
+            return MoveViewportAction.create(moveX, moveY);
+        }
+        return;
+    }
+
+    protected moveElement(element: SelectableBoundsAware, offSetX: number, offSetY: number): ChangeBoundsOperation {
+        return ChangeBoundsOperation.create([
+            {
+                elementId: element.id,
+                newSize: {
+                    width: element.bounds.width,
+                    height: element.bounds.height
+                },
+                newPosition: {
+                    x: element.bounds.x + offSetX,
+                    y: element.bounds.y + offSetY
+                }
+            }
+        ]);
+    }
+
+    protected move(viewport: GModelRoot & Viewport, selectedElements: SelectableBoundsAware[], deltaX: number, deltaY: number): Action[] {
+        const results: Action[] = [];
+
+        if (selectedElements.length !== 0) {
+            selectedElements.forEach(currentElement => {
+                results.push(this.moveElement(currentElement, deltaX, deltaY));
+                const newPosition = this.getBounds(currentElement, deltaX, deltaY);
+                const viewportAction = this.adaptViewport(viewport, newPosition, deltaX, deltaY);
+                if (viewportAction) {
+                    results.push(viewportAction);
+                }
+            });
+        }
+        return results;
+    }
+}

package/src/features/accessibility/move-zoom/move-zoom-module.ts

@@ -0,0 +1,41 @@
+/********************************************************************************
+ * 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, configureActionHandler } from '@eclipse-glsp/sprotty';
+import { MoveElementAction, MoveElementHandler, MoveViewportAction, MoveViewportHandler } from './move-handler';
+import { ZoomElementAction, ZoomElementHandler, ZoomViewportAction, ZoomViewportHandler } from './zoom-handler';
+
+/**
+ * Handles move and zoom actions.
+ */
+export const moveZoomModule = new FeatureModule((bind, unbind, isBound, rebind) => {
+    const context = { bind, unbind, isBound, rebind };
+    configureMoveZoom(context);
+});
+
+export function configureMoveZoom(context: BindingContext): void {
+    context.bind(MoveViewportHandler).toSelf().inSingletonScope();
+    context.bind(MoveElementHandler).toSelf().inSingletonScope();
+
+    context.bind(ZoomViewportHandler).toSelf().inSingletonScope();
+    context.bind(ZoomElementHandler).toSelf().inSingletonScope();
+
+    configureActionHandler(context, MoveViewportAction.KIND, MoveViewportHandler);
+    configureActionHandler(context, MoveElementAction.KIND, MoveElementHandler);
+
+    configureActionHandler(context, ZoomViewportAction.KIND, ZoomViewportHandler);
+    configureActionHandler(context, ZoomElementAction.KIND, ZoomElementHandler);
+}

package/src/features/accessibility/move-zoom/zoom-handler.ts

@@ -0,0 +1,182 @@
+/********************************************************************************
+ * 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 { throttle } from 'lodash';
+import {
+    Action,
+    Bounds,
+    GChildElement,
+    IActionDispatcher,
+    IActionHandler,
+    ICommand,
+    Point,
+    GModelElement,
+    GModelRoot,
+    SetViewportAction,
+    TYPES,
+    Viewport,
+    findParentByFeature,
+    isViewport
+} from '@eclipse-glsp/sprotty';
+import { EditorContextService } from '../../../base/editor-context-service';
+import { SelectableBoundsAware, getElements, isSelectableAndBoundsAware } from '../../../utils/gmodel-util';
+
+/**
+ * Action for triggering zooming of the viewport.
+ */
+export interface ZoomViewportAction extends Action {
+    kind: typeof ZoomViewportAction.KIND;
+    /**
+     * used to specify the amount by which the viewport should be zoomed
+     */
+    zoomFactor: number;
+}
+
+export namespace ZoomViewportAction {
+    export const KIND = 'zoomViewportAction';
+
+    export function is(object: any): object is ZoomViewportAction {
+        return Action.hasKind(object, KIND);
+    }
+
+    export function create(zoomFactor: number): ZoomViewportAction {
+        return { kind: KIND, zoomFactor };
+    }
+}
+
+/**
+ * Action for triggering zooming of the elements..
+ */
+export interface ZoomElementAction extends Action {
+    kind: typeof ZoomElementAction.KIND;
+    /**
+     * used to specify the elements to be zoomed in/out
+     */
+    elementIds: string[];
+    /**
+     * used to specify the amount by which the viewport should be zoomed
+     */
+    zoomFactor: number;
+}
+
+export namespace ZoomElementAction {
+    export const KIND = 'zoomElementAction';
+
+    export function is(object: any): object is ZoomElementAction {
+        return Action.hasKind(object, KIND);
+    }
+
+    export function create(elementIds: string[], zoomFactor: number): ZoomElementAction {
+        return { kind: KIND, elementIds, zoomFactor };
+    }
+}
+
+/* The ZoomViewportHandler class is an implementation of the IActionHandler interface that handles
+zooming in and out of a viewport. */
+@injectable()
+export class ZoomViewportHandler implements IActionHandler {
+    @inject(EditorContextService)
+    protected editorContextService: EditorContextService;
+
+    static readonly defaultZoomInFactor = 1.1;
+    static readonly defaultZoomOutFactor = 0.9;
+
+    @inject(TYPES.IActionDispatcher) protected dispatcher: IActionDispatcher;
+    protected readonly throttledHandleViewportZoom = throttle((action: ZoomViewportAction) => this.handleZoomViewport(action), 150);
+
+    handle(action: Action): void {
+        if (ZoomViewportAction.is(action)) {
+            this.throttledHandleViewportZoom(action);
+        }
+    }
+
+    handleZoomViewport(action: ZoomViewportAction): void {
+        const viewport = findParentByFeature(this.editorContextService.modelRoot, isViewport);
+        if (!viewport) {
+            return;
+        }
+        this.dispatcher.dispatch(this.setNewZoomFactor(viewport, action.zoomFactor));
+    }
+
+    protected setNewZoomFactor(viewport: GModelRoot & Viewport, zoomFactor: number): SetViewportAction {
+        const newZoom = viewport.zoom * zoomFactor;
+
+        const newViewport = {
+            scroll: viewport.scroll,
+            zoom: newZoom
+        };
+
+        return SetViewportAction.create(viewport.id, newViewport, { animate: true });
+    }
+}
+
+/* The ZoomElementHandler class is an implementation of the IActionHandler interface that handles
+zooming in and out of elements. */
+@injectable()
+export class ZoomElementHandler implements IActionHandler {
+    @inject(EditorContextService)
+    protected editorContextService: EditorContextService;
+    @inject(TYPES.IActionDispatcher) protected dispatcher: IActionDispatcher;
+    protected readonly throttledHandleElementZoom = throttle((action: ZoomElementAction) => this.handleZoomElement(action), 150);
+
+    handle(action: Action): void | Action | ICommand {
+        if (ZoomElementAction.is(action)) {
+            this.throttledHandleElementZoom(action);
+        }
+    }
+
+    handleZoomElement(action: ZoomElementAction): void {
+        const viewport = findParentByFeature(this.editorContextService.modelRoot, isViewport);
+        if (!viewport) {
+            return;
+        }
+
+        const elements = getElements(this.editorContextService.modelRoot.index, action.elementIds, isSelectableAndBoundsAware);
+        const center = this.getCenter(viewport, elements);
+        this.dispatcher.dispatch(this.setNewZoomFactor(viewport, action.zoomFactor, center));
+    }
+
+    protected getCenter(viewport: GModelRoot & Viewport, selectedElements: SelectableBoundsAware[]): Point {
+        // Get bounds of elements based on the viewport
+        const allBounds = selectedElements.map(e => this.boundsInViewport(viewport, e, e.bounds));
+        const mergedBounds = allBounds.reduce((b0, b1) => Bounds.combine(b0, b1));
+        return Bounds.center(mergedBounds);
+    }
+
+    // copy from center-fit.ts, translates the children bounds to the viewport bounds
+    protected boundsInViewport(viewport: GModelRoot & Viewport, element: GModelElement, bounds: Bounds): Bounds {
+        if (element instanceof GChildElement && element.parent !== viewport) {
+            return this.boundsInViewport(viewport, element.parent, element.parent.localToParent(bounds) as Bounds);
+        } else {
+            return bounds;
+        }
+    }
+
+    protected setNewZoomFactor(viewport: GModelRoot & Viewport, zoomFactor: number, point: Point): SetViewportAction {
+        const newZoom = viewport.zoom * zoomFactor;
+
+        const newViewport = {
+            scroll: {
+                x: point.x - (0.5 * viewport.canvasBounds.width) / newZoom,
+                y: point.y - (0.5 * viewport.canvasBounds.height) / newZoom
+            },
+            zoom: newZoom
+        };
+
+        return SetViewportAction.create(viewport.id, newViewport, { animate: true });
+    }
+}

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,
+    GModelElement,
+    GParentElement,
+    TYPES
+} from '@eclipse-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/gmodel-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 GModelElement & GParentElement & 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 '@eclipse-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);
+}