@eclipse-glsp/client 2.2.0-next.332 → 2.2.0-next.334

package/src/features/helper-lines/helper-line-feedback.ts

@@ -27,6 +27,7 @@ import {
     Point,
     TYPES,
     Viewport,
+    equalUpTo,
     findParentByFeature,
     isBoundsAware,
     isDecoration,
@@ -293,7 +294,7 @@ export class DrawHelperLinesFeedbackCommand extends FeedbackCommand {
     }
 
     protected isMatch(leftCoordinate: number, rightCoordinate: number, epsilon: number): boolean {
-        return Math.abs(leftCoordinate - rightCoordinate) <= epsilon;
+        return equalUpTo(leftCoordinate, rightCoordinate, epsilon);
     }
 
     protected log(message: string, ...params: any[]): void {

package/src/features/helper-lines/helper-line-manager-default.ts

@@ -13,7 +13,18 @@
  *
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
-import { Action, GModelElement, GModelRoot, IActionHandler, MoveAction, Point, SetBoundsAction, TYPES } from '@eclipse-glsp/sprotty';
+import {
+    Action,
+    GModelElement,
+    GModelRoot,
+    IActionHandler,
+    MoveAction,
+    Point,
+    SetBoundsAction,
+    TYPES,
+    Vector,
+    Writable
+} from '@eclipse-glsp/sprotty';
 import { inject, injectable, optional, postConstruct } from 'inversify';
 import { FeedbackEmitter } from '../../base';
 import { IFeedbackActionDispatcher } from '../../base/feedback/feedback-action-dispatcher';
@@ -33,7 +44,7 @@ import {
     ViewportLineType
 } from './helper-line-feedback';
 import { IHelperLineManager } from './helper-line-manager';
-import { Direction, HelperLineType } from './model';
+import { Direction, HelperLine, HelperLineType, isHelperLine } from './model';
 
 export interface IHelperLineOptions {
     /**
@@ -158,4 +169,28 @@ export class HelperLineManager implements IActionHandler, ISelectionListener, IH
             ? this.options.minimumMoveDelta.x
             : this.options.minimumMoveDelta.y;
     }
+
+    getMinimumMoveVector(element: GModelElement, isSnap: boolean, directions: Direction[]): Vector | undefined {
+        if (!isSnap) {
+            return undefined;
+        }
+
+        const helperLines = element.root.children.filter(child => isHelperLine(child)) as HelperLine[];
+        if (helperLines.length === 0) {
+            return undefined;
+        }
+
+        const minimum: Writable<Vector> = { ...Vector.ZERO };
+        if (directions.includes(Direction.Left) && helperLines.some(line => line.isLeft || line.isCenter)) {
+            minimum.x = this.getMinimumMoveDelta(element, isSnap, Direction.Left);
+        } else if (directions.includes(Direction.Right) && helperLines.some(line => line.isRight || line.isCenter)) {
+            minimum.x = this.getMinimumMoveDelta(element, isSnap, Direction.Right);
+        }
+        if (directions.includes(Direction.Up) && helperLines.some(line => line.isTop || line.isMiddle)) {
+            minimum.y = this.getMinimumMoveDelta(element, isSnap, Direction.Up);
+        } else if (directions.includes(Direction.Down) && helperLines.some(line => line.isBottom || line.isMiddle)) {
+            minimum.y = this.getMinimumMoveDelta(element, isSnap, Direction.Down);
+        }
+        return Vector.isZero(minimum) ? undefined : minimum;
+    }
 }

package/src/features/helper-lines/helper-line-manager.ts

@@ -13,16 +13,25 @@
  *
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
-import { GModelElement } from '@eclipse-glsp/sprotty';
+import { GModelElement, Vector } from '@eclipse-glsp/sprotty';
 import { Direction } from './model';
 
 export interface IHelperLineManager {
     /**
-     * Calculates the minimum move delta that is necessary to break through a helper line.
+     * Calculates the minimum move delta on one axis that is necessary to break through a helper line.
      *
      * @param element element that is being moved
      * @param isSnap whether snapping is active or not
      * @param direction direction in which the target element is moving
      */
     getMinimumMoveDelta(element: GModelElement, isSnap: boolean, direction: Direction): number;
+
+    /**
+     * Calculates the minimum move vector that is necessary to break through a helper line.
+     *
+     * @param element element that is being moved
+     * @param isSnap whether snapping is active or not
+     * @param directions directions in which the target element is moving
+     */
+    getMinimumMoveVector(element: GModelElement, isSnap: boolean, directions: Direction[]): Vector | undefined;
 }

package/src/features/routing/edge-router.ts

@@ -41,6 +41,13 @@ export abstract class GLSPAbstractEdgeRouter extends AbstractEdgeRouter {
         const anchor = super.getTranslatedAnchor(connectable, refPoint, refContainer, edge, anchorCorrection);
         return Point.isValid(anchor) ? anchor : refPoint;
     }
+
+    override cleanupRoutingPoints(edge: GRoutableElement, routingPoints: Point[], updateHandles: boolean, addRoutingPoints: boolean): void {
+        // sometimes it might happen that the source or target has the bounds not properly set when using the feedback edge
+        if (ensureBounds(edge.source) && ensureBounds(edge.target)) {
+            super.cleanupRoutingPoints(edge, routingPoints, updateHandles, addRoutingPoints);
+        }
+    }
 }
 
 @injectable()
@@ -56,6 +63,13 @@ export class GLSPPolylineEdgeRouter extends PolylineEdgeRouter {
         const anchor = super.getTranslatedAnchor(connectable, refPoint, refContainer, edge, anchorCorrection);
         return Point.isValid(anchor) ? anchor : refPoint;
     }
+
+    override cleanupRoutingPoints(edge: GRoutableElement, routingPoints: Point[], updateHandles: boolean, addRoutingPoints: boolean): void {
+        // sometimes it might happen that the source or target has the bounds not properly set when using the feedback edge
+        if (ensureBounds(edge.source) && ensureBounds(edge.target)) {
+            super.cleanupRoutingPoints(edge, routingPoints, updateHandles, addRoutingPoints);
+        }
+    }
 }
 
 @injectable()
@@ -111,6 +125,13 @@ export class GLSPManhattanEdgeRouter extends ManhattanEdgeRouter {
             }
         });
     }
+
+    override cleanupRoutingPoints(edge: GRoutableElement, routingPoints: Point[], updateHandles: boolean, addRoutingPoints: boolean): void {
+        // sometimes it might happen that the source or target has the bounds not properly set when using the feedback edge
+        if (ensureBounds(edge.source) && ensureBounds(edge.target)) {
+            super.cleanupRoutingPoints(edge, routingPoints, updateHandles, addRoutingPoints);
+        }
+    }
 }
 
 @injectable()
@@ -126,4 +147,25 @@ export class GLSPBezierEdgeRouter extends BezierEdgeRouter {
         const anchor = super.getTranslatedAnchor(connectable, refPoint, refContainer, edge, anchorCorrection);
         return Point.isValid(anchor) ? anchor : refPoint;
     }
+
+    override cleanupRoutingPoints(edge: GRoutableElement, routingPoints: Point[], updateHandles: boolean, addRoutingPoints: boolean): void {
+        // sometimes it might happen that the source or target has the bounds not properly set when using the feedback edge
+        if (ensureBounds(edge.source) && ensureBounds(edge.target)) {
+            super.cleanupRoutingPoints(edge, routingPoints, updateHandles, addRoutingPoints);
+        }
+    }
+}
+
+function ensureBounds(element?: GConnectableElement): boolean {
+    if (!element) {
+        return false;
+    }
+    if (element.bounds) {
+        return true;
+    }
+    if (element.position && element.size) {
+        element.bounds = { ...element.position, ...element.size };
+        return true;
+    }
+    return false;
 }

package/src/features/select/select-mouse-listener.ts

@@ -13,17 +13,23 @@
  *
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
-import { Action, BringToFrontAction, GModelElement, SelectAction, SelectMouseListener } from '@eclipse-glsp/sprotty';
+import { Action, BringToFrontAction, GModelElement, SelectAction, SelectMouseListener, TYPES } from '@eclipse-glsp/sprotty';
+import { inject, injectable, optional } from 'inversify';
 import { Ranked } from '../../base/ranked';
 import { SelectableElement } from '../../utils';
+import { SResizeHandle } from '../change-bounds';
+import { ChangeBoundsManager } from '../tools';
 
 /**
  * Ranked select mouse listener that is executed before default mouse listeners when using the RankedMouseTool.
  * This ensures that default mouse listeners are working on a model that has selection changes already applied.
  */
+@injectable()
 export class RankedSelectMouseListener extends SelectMouseListener implements Ranked {
     rank: number = Ranked.DEFAULT_RANK - 100; /* we want to be executed before all default mouse listeners */
 
+    @inject(TYPES.IChangeBoundsManager) @optional() readonly changeBoundsManager?: ChangeBoundsManager;
+
     protected override handleSelectTarget(
         selectableTarget: SelectableElement,
         deselectedElements: GModelElement[],
@@ -52,4 +58,12 @@ export class RankedSelectMouseListener extends SelectMouseListener implements Ra
         result.push(SelectAction.create({ selectedElementsIDs: [], deselectedElementsIDs: deselectedElements.map(e => e.id) }));
         return result;
     }
+
+    protected override handleButton(target: GModelElement, event: MouseEvent): (Action | Promise<Action>)[] | undefined {
+        if (target instanceof SResizeHandle && this.changeBoundsManager?.useSymmetricResize(event)) {
+            // avoid de-selecting elements when resizing with a modifier key
+            return [];
+        }
+        return super.handleButton(target, event);
+    }
 }

package/src/features/tools/base-tools.ts

@@ -23,11 +23,41 @@ import { EnableToolsAction, Tool } from '../../base/tool-manager/tool';
 import { GLSPKeyTool } from '../../base/view/key-tool';
 import { GLSPMouseTool } from '../../base/view/mouse-tool';
 
+export interface FeedbackAwareTool extends Tool {
+    /**
+     * Creates a new feedback emitter helper object. While anything can serve as a feedback emitter,
+     * this method ensures that the emitter is stable and does not change between model updates.
+     */
+    createFeedbackEmitter(): FeedbackEmitter;
+
+    /**
+     * Registers `actions` to be sent out as feedback, i.e., changes that are re-established whenever the `GModelRoot`
+     * has been set or updated.
+     *
+     * @param feedbackActions the actions to be sent out.
+     * @param feedbackEmitter the emitter sending out feedback actions (this tool by default).
+     * @param cleanupActions the actions to be sent out when the feedback is de-registered through the returned Disposable.
+     * @returns A 'Disposable' that de-registers the feedback and cleans up any pending feedback with the given `cleanupActions`.
+     * @deprecated It is recommended to create a {@link createFeedbackEmitter dedicated emitter} per feedback instead of using the tool.
+     */
+    registerFeedback(feedbackActions: Action[], feedbackEmitter?: IFeedbackEmitter, cleanupActions?: MaybeActions): Disposable;
+
+    /**
+     * De-registers all feedback from the given `feedbackEmitter` (this tool by default) and cleans up any pending feedback with the
+     * given `cleanupActions`.
+     *
+     * @param feedbackEmitter the emitter to be deregistered (this tool by default).
+     * @param cleanupActions the actions to be dispatched right after the deregistration to clean up any pending feedback.
+     * @deprecated It is recommended to create a {@link createFeedbackEmitter dedicated emitter} per feedback and dispose it like that.
+     */
+    deregisterFeedback(feedbackEmitter?: IFeedbackEmitter, cleanupActions?: MaybeActions): void;
+}
+
 /**
  *  A reusable base implementation for edit {@link Tool}s.
  */
 @injectable()
-export abstract class BaseEditTool implements Tool {
+export abstract class BaseEditTool implements FeedbackAwareTool {
     @inject(TYPES.IFeedbackActionDispatcher) protected feedbackDispatcher: IFeedbackActionDispatcher;
     @inject(TYPES.IActionDispatcher) protected actionDispatcher: GLSPActionDispatcher;
     @inject(GLSPMouseTool) protected mouseTool: GLSPMouseTool;
@@ -56,28 +86,10 @@ export abstract class BaseEditTool implements Tool {
         return this.feedbackDispatcher.createEmitter();
     }
 
-    /**
-     * Registers `actions` to be sent out as feedback, i.e., changes that are re-established whenever the `GModelRoot`
-     * has been set or updated.
-     *
-     * @param feedbackActions the actions to be sent out.
-     * @param feedbackEmitter the emitter sending out feedback actions (this tool by default).
-     * @param cleanupActions the actions to be sent out when the feedback is de-registered through the returned Disposable.
-     * @returns A 'Disposable' that de-registers the feedback and cleans up any pending feedback with the given `cleanupActions`.
-     * @deprecated It is recommended to create a {@link createFeedbackEmitter dedicated emitter} per feedback instead of using the tool.
-     */
     registerFeedback(feedbackActions: Action[], feedbackEmitter: IFeedbackEmitter = this, cleanupActions?: MaybeActions): Disposable {
         return this.feedbackDispatcher.registerFeedback(feedbackEmitter, feedbackActions, cleanupActions);
     }
 
-    /**
-     * De-registers all feedback from the given `feedbackEmitter` (this tool by default) and cleans up any pending feedback with the
-     * given `cleanupActions`.
-     *
-     * @param feedbackEmitter the emitter to be deregistered (this tool by default).
-     * @param cleanupActions the actions to be dispatched right after the deregistration to clean up any pending feedback.
-     * @deprecated It is recommended to create a {@link createFeedbackEmitter dedicated emitter} per feedback and dispose it like that.
-     */
     deregisterFeedback(feedbackEmitter: IFeedbackEmitter = this, cleanupActions?: MaybeActions): void {
         this.feedbackDispatcher.deregisterFeedback(feedbackEmitter, cleanupActions);
     }

package/src/features/tools/change-bounds/change-bounds-manager.ts

@@ -0,0 +1,145 @@
+/********************************************************************************
+ * Copyright (c) 2024 Axon Ivy AG 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 {
+    Dimension,
+    GModelElement,
+    ISnapper,
+    KeyboardModifier,
+    MousePositionTracker,
+    Movement,
+    Point,
+    TYPES,
+    Vector,
+    isBoundsAware,
+    isLocateable
+} from '@eclipse-glsp/sprotty';
+import { inject, injectable, optional } from 'inversify';
+import { FeedbackEmitter } from '../../../base';
+import { isValidMove, minDimensions } from '../../../utils';
+import { LayoutAware } from '../../bounds/layout-data';
+import {
+    IMovementRestrictor,
+    ResizeHandleLocation,
+    movementRestrictionFeedback,
+    removeMovementRestrictionFeedback
+} from '../../change-bounds';
+import { IHelperLineManager } from '../../helper-lines';
+import { ChangeBoundsTracker, TrackedElementMove } from './change-bounds-tracker';
+
+export const CSS_RESIZE_MODE = 'resize-mode';
+
+@injectable()
+export class ChangeBoundsManager {
+    constructor(
+        @inject(MousePositionTracker) readonly positionTracker: MousePositionTracker,
+        @optional() @inject(TYPES.IMovementRestrictor) readonly movementRestrictor?: IMovementRestrictor,
+        @optional() @inject(TYPES.ISnapper) readonly snapper?: ISnapper,
+        @optional() @inject(TYPES.IHelperLineManager) readonly helperLineManager?: IHelperLineManager
+    ) {}
+
+    unsnapModifier(): KeyboardModifier | undefined {
+        return 'shift';
+    }
+
+    usePositionSnap(arg: MouseEvent | KeyboardEvent | any): boolean {
+        return typeof arg === 'boolean' ? arg : !(arg as MouseEvent | KeyboardEvent).shiftKey;
+    }
+
+    snapPosition(element: GModelElement, position: Point): Point {
+        return this.snapper?.snap(position, element) ?? position;
+    }
+
+    isValid(element: GModelElement): boolean {
+        return this.hasValidPosition(element) && this.hasValidSize(element);
+    }
+
+    hasValidPosition(element: GModelElement, position?: Point): boolean {
+        return !isLocateable(element) || isValidMove(element, position ?? element.position, this.movementRestrictor);
+    }
+
+    hasValidSize(element: GModelElement, size?: Dimension): boolean {
+        if (!isBoundsAware(element)) {
+            return true;
+        }
+        const dimension: Dimension = size ?? element.bounds;
+        const minimum = this.getMinimumSize(element);
+        if (dimension.width < minimum.width || dimension.height < minimum.height) {
+            return false;
+        }
+        return true;
+    }
+
+    getMinimumSize(element: GModelElement): Dimension {
+        if (!isBoundsAware(element)) {
+            return Dimension.EMPTY;
+        }
+        const definedMinimum = minDimensions(element);
+        const computedMinimum = LayoutAware.getComputedDimensions(element);
+        return computedMinimum
+            ? {
+                  width: Math.max(definedMinimum.width, computedMinimum.width),
+                  height: Math.max(definedMinimum.height, computedMinimum.height)
+              }
+            : definedMinimum;
+    }
+
+    useMovementRestriction(arg: MouseEvent | KeyboardEvent | any): boolean {
+        return this.usePositionSnap(arg);
+    }
+
+    restrictMovement(element: GModelElement, movement: Movement): Movement {
+        const minimumMovement = this.helperLineManager?.getMinimumMoveVector(element, true, movement.direction);
+        if (!minimumMovement) {
+            return movement;
+        }
+        // minimum is given in absolute coordinates
+        // if minimum is not reached, reset to original position for that coordinate
+        const absVector = Vector.abs(movement.vector);
+        const targetPosition: Point = {
+            x: absVector.x < minimumMovement.x ? movement.from.x : movement.to.x,
+            y: absVector.y < minimumMovement.y ? movement.from.y : movement.to.y
+        };
+        return Point.move(movement.from, targetPosition);
+    }
+
+    addRestrictionFeedback(feedback: FeedbackEmitter, move: TrackedElementMove): FeedbackEmitter {
+        if (this.movementRestrictor) {
+            feedback.add(
+                movementRestrictionFeedback(move.element, this.movementRestrictor!, move.valid),
+                removeMovementRestrictionFeedback(move.element, this.movementRestrictor!)
+            );
+        }
+        return feedback;
+    }
+
+    defaultResizeLocations(): ResizeHandleLocation[] {
+        return [
+            ResizeHandleLocation.TopLeft,
+            ResizeHandleLocation.TopRight,
+            ResizeHandleLocation.BottomRight,
+            ResizeHandleLocation.BottomLeft
+        ];
+    }
+
+    useSymmetricResize(arg: MouseEvent | KeyboardEvent | any): boolean {
+        return typeof arg === 'boolean' ? arg : (arg as MouseEvent | KeyboardEvent).ctrlKey;
+    }
+
+    createTracker(): ChangeBoundsTracker {
+        return new ChangeBoundsTracker(this);
+    }
+}

package/src/features/tools/change-bounds/change-bounds-tool-feedback.ts

@@ -19,12 +19,14 @@ import { inject, injectable } from 'inversify';
 import { FeedbackCommand } from '../../../base/feedback/feedback-command';
 import { OptionalAction } from '../../../base/model/glsp-model-source';
 import { forEachElement } from '../../../utils/gmodel-util';
-import { addResizeHandles, isResizable, removeResizeHandles } from '../../change-bounds/model';
+import { ResizeHandleLocation, addResizeHandles, isResizable, removeResizeHandles } from '../../change-bounds/model';
+import { ChangeBoundsManager } from './change-bounds-manager';
 
 export interface ShowChangeBoundsToolResizeFeedbackAction extends Action {
     kind: typeof ShowChangeBoundsToolResizeFeedbackAction.KIND;
 
     elementId: string;
+    resizeLocations?: ResizeHandleLocation[];
 }
 
 export namespace ShowChangeBoundsToolResizeFeedbackAction {
@@ -34,10 +36,16 @@ export namespace ShowChangeBoundsToolResizeFeedbackAction {
         return Action.hasKind(object, KIND) && hasStringProp(object, 'elementId');
     }
 
-    export function create(elementId: string): ShowChangeBoundsToolResizeFeedbackAction {
+    /** @deprecated Use the create method with the options object parameter instead and set the 'elementId' parameter. */
+    export function create(elementId: string): ShowChangeBoundsToolResizeFeedbackAction;
+    export function create(options: Omit<ShowChangeBoundsToolResizeFeedbackAction, 'kind'>): ShowChangeBoundsToolResizeFeedbackAction;
+    export function create(
+        options: Omit<ShowChangeBoundsToolResizeFeedbackAction, 'kind'> | string
+    ): ShowChangeBoundsToolResizeFeedbackAction {
+        const opts = typeof options === 'string' ? { elementId: options } : options;
         return {
             kind: KIND,
-            elementId
+            ...opts
         };
     }
 }
@@ -63,15 +71,18 @@ export class ShowChangeBoundsToolResizeFeedbackCommand extends FeedbackCommand {
     static readonly KIND = ShowChangeBoundsToolResizeFeedbackAction.KIND;
 
     @inject(TYPES.Action) protected action: ShowChangeBoundsToolResizeFeedbackAction;
+    @inject(TYPES.IChangeBoundsManager) protected changeBoundsManager: ChangeBoundsManager;
 
     execute(context: CommandExecutionContext): CommandReturn {
         const index = context.root.index;
 
         forEachElement(index, isResizable, element => element.id !== this.action.elementId && removeResizeHandles(element));
 
-        const resizeElement = index.getById(this.action.elementId);
-        if (resizeElement && isResizable(resizeElement)) {
-            addResizeHandles(resizeElement);
+        if (this.action.elementId) {
+            const resizeElement = index.getById(this.action.elementId);
+            if (resizeElement && isResizable(resizeElement)) {
+                addResizeHandles(resizeElement, this.action.resizeLocations ?? this.changeBoundsManager.defaultResizeLocations());
+            }
         }
         return context.root;
     }

package/src/features/tools/change-bounds/change-bounds-tool-module.ts

@@ -16,12 +16,14 @@
 import { FeatureModule, TYPES, bindAsService, configureCommand, configureView } from '@eclipse-glsp/sprotty';
 import '../../../../css/change-bounds.css';
 import { SResizeHandle } from '../../change-bounds/model';
+import { ChangeBoundsManager } from './change-bounds-manager';
 import { ChangeBoundsTool } from './change-bounds-tool';
 import { HideChangeBoundsToolResizeFeedbackCommand, ShowChangeBoundsToolResizeFeedbackCommand } from './change-bounds-tool-feedback';
 import { SResizeHandleView } from './view';
 
 export const changeBoundsToolModule = new FeatureModule((bind, unbind, isBound, rebind) => {
     const context = { bind, unbind, isBound, rebind };
+    bindAsService(context, TYPES.IChangeBoundsManager, ChangeBoundsManager);
     bindAsService(context, TYPES.IDefaultTool, ChangeBoundsTool);
     configureCommand(context, ShowChangeBoundsToolResizeFeedbackCommand);
     configureCommand(context, HideChangeBoundsToolResizeFeedbackCommand);