@eclipse-glsp/client 2.2.0-next.333 → 2.2.0-next.335

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);

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

@@ -13,29 +13,18 @@
  *
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
-import { Action, Disposable, ElementMove, GModelElement, GModelRoot, MoveAction, Point, findParentByFeature } from '@eclipse-glsp/sprotty';
+import { Action, ElementMove, GModelElement, GModelRoot, MoveAction, Point, findParentByFeature } from '@eclipse-glsp/sprotty';
 
 import { DebouncedFunc, debounce } from 'lodash';
+import { ChangeBoundsTracker, TrackedMove } from '.';
 import { DragAwareMouseListener } from '../../../base/drag-aware-mouse-listener';
 import { CursorCSS, cursorFeedbackAction } from '../../../base/feedback/css-feedback';
 import { FeedbackEmitter } from '../../../base/feedback/feeback-emitter';
 import { MoveableElement, filter, getElements, isNonRoutableSelectedMovableBoundsAware, removeDescendants } from '../../../utils';
-import { PointPositionUpdater } from '../../change-bounds';
 import { SResizeHandle } from '../../change-bounds/model';
-import { createMovementRestrictionFeedback, removeMovementRestrictionFeedback } from '../../change-bounds/movement-restrictor';
 import { ChangeBoundsTool } from './change-bounds-tool';
 import { MoveFinishedEventAction, MoveInitializedEventAction } from './change-bounds-tool-feedback';
 
-export interface ValidatedElementMove extends ElementMove {
-    valid: boolean;
-}
-
-export namespace ValidatedElementMove {
-    export function isValid(move: ElementMove): boolean {
-        return (move as ValidatedElementMove).valid ?? true;
-    }
-}
-
 /**
  * This mouse listener provides visual feedback for moving by sending client-side
  * `MoveAction`s while elements are selected and dragged. This will also update
@@ -43,9 +32,9 @@ export namespace ValidatedElementMove {
  * the visual feedback but also the basis for sending the change to the server
  * (see also `tools/MoveTool`).
  */
-export class FeedbackMoveMouseListener extends DragAwareMouseListener implements Disposable {
+export class FeedbackMoveMouseListener extends DragAwareMouseListener {
     protected rootElement?: GModelRoot;
-    protected positionUpdater;
+    protected tracker: ChangeBoundsTracker;
     protected elementId2startPos = new Map<string, Point>();
 
     protected pendingMoveInitialized?: DebouncedFunc<() => void>;
@@ -55,7 +44,7 @@ export class FeedbackMoveMouseListener extends DragAwareMouseListener implements
 
     constructor(protected tool: ChangeBoundsTool) {
         super();
-        this.positionUpdater = new PointPositionUpdater(tool.positionSnapper);
+        this.tracker = tool.createChangeBoundsTracker();
         this.moveInitializedFeedback = tool.createFeedbackEmitter();
         this.moveFeedback = tool.createFeedbackEmitter();
     }
@@ -66,7 +55,7 @@ export class FeedbackMoveMouseListener extends DragAwareMouseListener implements
             this.initializeMove(target, event);
             return [];
         }
-        this.positionUpdater.resetPosition();
+        this.tracker.stopTracking();
         return [];
     }
 
@@ -77,10 +66,10 @@ export class FeedbackMoveMouseListener extends DragAwareMouseListener implements
         }
         const moveable = findParentByFeature(target, this.isValidMoveable);
         if (moveable !== undefined) {
-            this.positionUpdater.updateLastDragPosition(event);
+            this.tracker.startTracking();
             this.scheduleMoveInitialized();
         } else {
-            this.positionUpdater.resetPosition();
+            this.tracker.stopTracking();
         }
     }
 
@@ -113,7 +102,7 @@ export class FeedbackMoveMouseListener extends DragAwareMouseListener implements
     override nonDraggingMouseUp(element: GModelElement, event: MouseEvent): Action[] {
         // should reset everything that may have happend on mouse down
         this.moveInitializedFeedback.dispose();
-        this.positionUpdater.resetPosition();
+        this.tracker.stopTracking();
         return [];
     }
 
@@ -121,7 +110,7 @@ export class FeedbackMoveMouseListener extends DragAwareMouseListener implements
         super.mouseMove(target, event);
         if (event.buttons === 0) {
             return this.mouseUp(target, event);
-        } else if (!this.positionUpdater.isLastDragPositionUndefined()) {
+        } else if (this.tracker.isTracking()) {
             return this.moveElements(target, event);
         }
         return [];
@@ -131,35 +120,34 @@ export class FeedbackMoveMouseListener extends DragAwareMouseListener implements
         if (this.elementId2startPos.size === 0) {
             this.initializeElementsToMove(target.root);
         }
-        const moveAction = this.getElementMoves(target, event, false);
-        if (!moveAction) {
+        const elementsToMove = this.getElementsToMove(target);
+        const move = this.tracker.moveElements(elementsToMove, { snap: event, restrict: event });
+        if (move.elementMoves.length === 0) {
             return [];
         }
         // cancel any pending move
         this.pendingMoveInitialized?.cancel();
-        this.moveFeedback.add(moveAction, () => this.resetElementPositions(target));
-        this.addMovementFeedback(moveAction, target);
+        this.moveFeedback.add(this.createMoveAction(move), () => this.resetElementPositions(target));
+        this.addMovementFeedback(move, target, event);
+        this.tracker.updateTrackingPosition(move);
         this.moveFeedback.submit();
         return [];
     }
 
-    protected addMovementFeedback(movement: MoveAction, ctx: GModelElement): void {
+    protected createMoveAction(trackedMove: TrackedMove): Action {
+        // we never want to animate the move action as this interferes with the move feedback
+        return MoveAction.create(
+            trackedMove.elementMoves.map(move => ({ elementId: move.element.id, toPosition: move.toPosition })),
+            { animate: false }
+        );
+    }
+
+    protected addMovementFeedback(trackedMove: TrackedMove, ctx: GModelElement, event: MouseEvent): void {
         // cursor feedback
         this.moveFeedback.add(cursorFeedbackAction(CursorCSS.MOVE), cursorFeedbackAction(CursorCSS.DEFAULT));
 
         // restriction feedback
-        movement.moves.forEach(move => {
-            const element = ctx.root.index.getById(move.elementId);
-            if (element && this.tool.movementRestrictor) {
-                if (!ValidatedElementMove.isValid(move)) {
-                    this.moveFeedback.add(createMovementRestrictionFeedback(element, this.tool.movementRestrictor), () =>
-                        removeMovementRestrictionFeedback(element, this.tool.movementRestrictor!)
-                    );
-                } else {
-                    this.moveFeedback.add(removeMovementRestrictionFeedback(element, this.tool.movementRestrictor));
-                }
-            }
-        });
+        trackedMove.elementMoves.forEach(move => this.tool.changeBoundsManager.addRestrictionFeedback(this.moveFeedback, move));
     }
 
     protected initializeElementsToMove(root: GModelRoot): void {
@@ -177,45 +165,6 @@ export class FeedbackMoveMouseListener extends DragAwareMouseListener implements
         return getElements(context.root.index, Array.from(this.elementId2startPos.keys()), this.isValidMoveable);
     }
 
-    protected getElementMoves(target: GModelElement, event: MouseEvent, finished: boolean): MoveAction | undefined {
-        const delta = this.positionUpdater.updatePosition(target, event);
-        if (!delta) {
-            return undefined;
-        }
-        const elementMoves: ElementMove[] = this.getElementMovesForDelta(target, delta, finished).filter(move =>
-            this.filterElementMove(move)
-        );
-        if (elementMoves.length > 0) {
-            // we never want to animate the move action as this interferes with the move feedback
-            return MoveAction.create(elementMoves, { animate: false, finished });
-        } else {
-            return undefined;
-        }
-    }
-
-    protected filterElementMove(elementMove: ValidatedElementMove): boolean {
-        return !!elementMove.fromPosition && !Point.equals(elementMove.fromPosition, elementMove.toPosition);
-    }
-
-    protected getElementMovesForDelta(target: GModelElement, delta: Point, finished: boolean): ValidatedElementMove[] {
-        return this.getElementsToMove(target).flatMap<ValidatedElementMove>(element => {
-            const startPosition = this.elementId2startPos.get(element.id);
-            if (!startPosition) {
-                return [];
-            }
-            const targetPosition = Point.add(element.position, delta);
-            const valid = this.tool.movementRestrictor?.validate(element, targetPosition) ?? true;
-            return [this.createElementMove(element, targetPosition, valid, finished)];
-        });
-    }
-
-    protected createElementMove(element: MoveableElement, toPosition: Point, valid: boolean, finished: boolean): ValidatedElementMove {
-        // if we are finished and have an invalid move, we want to move the element back to its start position
-        return !valid && finished
-            ? { elementId: element.id, fromPosition: element.position, toPosition: element.position, valid }
-            : { elementId: element.id, fromPosition: element.position, toPosition, valid };
-    }
-
     protected resetElementPositions(context: GModelElement): MoveAction | undefined {
         const elementMoves: ElementMove[] = this.revertElementMoves(context);
         return MoveAction.create(elementMoves, { animate: false, finished: true });
@@ -233,12 +182,13 @@ export class FeedbackMoveMouseListener extends DragAwareMouseListener implements
     }
 
     override draggingMouseUp(target: GModelElement, event: MouseEvent): Action[] {
-        if (this.positionUpdater.isLastDragPositionUndefined()) {
+        if (!this.tracker.isTracking()) {
             return [];
         }
         // only reset the move of invalid elements, the others will be handled by the change bounds tool itself
-        const moves = this.getElementMovesForDelta(target, Point.ORIGIN, false);
-        moves.filter(move => move.valid).forEach(move => this.elementId2startPos.delete(move.elementId));
+        this.getElementsToMove(target)
+            .filter(element => this.tool.changeBoundsManager.isValid(element))
+            .forEach(element => this.elementId2startPos.delete(element.id));
         this.dispose();
         return [];
     }
@@ -247,7 +197,7 @@ export class FeedbackMoveMouseListener extends DragAwareMouseListener implements
         this.pendingMoveInitialized?.cancel();
         this.moveInitializedFeedback.dispose();
         this.moveFeedback.dispose();
-        this.positionUpdater.resetPosition();
+        this.tracker.dispose();
         this.elementId2startPos.clear();
         super.dispose();
     }