@eclipse-glsp/client 2.3.0-next.322 → 2.3.0-next.363

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

@@ -1,5 +1,5 @@
 /********************************************************************************
- * Copyright (c) 2019-2023 EclipseSource and others.
+ * Copyright (c) 2019-2024 EclipseSource 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
@@ -17,7 +17,6 @@ import { inject, injectable, optional } from 'inversify';
 
 import {
     Action,
-    Bounds,
     BoundsAware,
     ChangeBoundsOperation,
     ChangeRoutingPointsOperation,
@@ -36,35 +35,33 @@ import {
     Operation,
     Point,
     TYPES,
-    findParentByFeature,
-    isSelected
+    findParentByFeature
 } from '@eclipse-glsp/sprotty';
 import { DragAwareMouseListener } from '../../../base/drag-aware-mouse-listener';
-import { CursorCSS, applyCssClasses, cursorFeedbackAction, deleteCssClasses } from '../../../base/feedback/css-feedback';
+import { FeedbackEmitter } from '../../../base/feedback/feedback-emitter';
 import { ISelectionListener, SelectionService } from '../../../base/selection-service';
-import { PointPositionUpdater } from '../../../features/change-bounds/point-position-updater';
 import {
+    BoundsAwareModelElement,
+    ResizableModelElement,
+    SelectableBoundsAware,
     calcElementAndRoutingPoints,
-    forEachElement,
+    getMatchingElements,
     isNonRoutableSelectedMovableBoundsAware,
     toElementAndBounds
 } from '../../../utils/gmodel-util';
-import { isValidMove, isValidSize } from '../../../utils/layout-utils';
+import { LocalRequestBoundsAction } from '../../bounds/local-bounds';
 import { SetBoundsFeedbackAction } from '../../bounds/set-bounds-feedback-command';
-import { Resizable, ResizeHandleLocation, SResizeHandle, isBoundsAwareMoveable, isResizable } from '../../change-bounds/model';
-import {
-    IMovementRestrictor,
-    createMovementRestrictionFeedback,
-    removeMovementRestrictionFeedback
-} from '../../change-bounds/movement-restrictor';
-import { PositionSnapper } from '../../change-bounds/position-snapper';
-import { getDirectionFrom } from '../../helper-lines/model';
+import { GResizeHandle, isResizable } from '../../change-bounds/model';
+import { IMovementRestrictor } from '../../change-bounds/movement-restrictor';
 import { BaseEditTool } from '../base-tools';
+import { CSS_ACTIVE_HANDLE, ChangeBoundsManager } from './change-bounds-manager';
 import {
-    FeedbackMoveMouseListener,
     HideChangeBoundsToolResizeFeedbackAction,
+    MoveFinishedEventAction,
     ShowChangeBoundsToolResizeFeedbackAction
 } from './change-bounds-tool-feedback';
+import { FeedbackMoveMouseListener } from './change-bounds-tool-move-feedback';
+import { ChangeBoundsTracker, TrackedElementResize, TrackedResize } from './change-bounds-tracker';
 
 /**
  * The change bounds tool has the license to move multiple elements or resize a single element by implementing the ChangeBounds operation.
@@ -86,7 +83,7 @@ export class ChangeBoundsTool extends BaseEditTool {
     @inject(SelectionService) protected selectionService: SelectionService;
     @inject(EdgeRouterRegistry) @optional() readonly edgeRouterRegistry?: EdgeRouterRegistry;
     @inject(TYPES.IMovementRestrictor) @optional() readonly movementRestrictor?: IMovementRestrictor;
-    @inject(PositionSnapper) readonly positionSnapper: PositionSnapper;
+    @inject(ChangeBoundsManager) readonly changeBoundsManager: ChangeBoundsManager;
 
     get id(): string {
         return ChangeBoundsTool.ID;
@@ -108,12 +105,14 @@ export class ChangeBoundsTool extends BaseEditTool {
         this.toDisposeOnDisable.push(
             this.mouseTool.registerListener(feedbackMoveMouseListener),
             this.mouseTool.registerListener(changeBoundsListener),
-            Disposable.create(() => this.deregisterFeedback(feedbackMoveMouseListener)),
-            Disposable.create(() => this.deregisterFeedback(changeBoundsListener, [HideChangeBoundsToolResizeFeedbackAction.create()])),
             this.selectionService.onSelectionChanged(change => changeBoundsListener.selectionChanged(change.root, change.selectedElements))
         );
     }
 
+    createChangeBoundsTracker(): ChangeBoundsTracker {
+        return this.changeBoundsManager.createTracker();
+    }
+
     protected createMoveMouseListener(): MouseListener {
         return new FeedbackMoveMouseListener(this);
     }
@@ -123,20 +122,24 @@ export class ChangeBoundsTool extends BaseEditTool {
     }
 }
 
-export class ChangeBoundsListener extends DragAwareMouseListener implements ISelectionListener, Disposable {
-    static readonly CSS_CLASS_ACTIVE = 'active';
+export class ChangeBoundsListener extends DragAwareMouseListener implements ISelectionListener {
+    static readonly CSS_CLASS_ACTIVE = CSS_ACTIVE_HANDLE;
 
     // members for calculating the correct position change
-    protected initialBounds: Bounds | undefined;
-    protected pointPositionUpdater: PointPositionUpdater;
+    protected initialBounds: ElementAndBounds | undefined;
+    protected tracker: ChangeBoundsTracker;
 
     // members for resize mode
-    protected activeResizeElement?: GModelElement;
-    protected activeResizeHandle?: SResizeHandle;
+    protected activeResizeElement?: ResizableModelElement;
+    protected activeResizeHandle?: GResizeHandle;
+    protected handleFeedback: FeedbackEmitter;
+    protected resizeFeedback: FeedbackEmitter;
 
     constructor(protected tool: ChangeBoundsTool) {
         super();
-        this.pointPositionUpdater = new PointPositionUpdater(tool.positionSnapper);
+        this.tracker = tool.createChangeBoundsTracker();
+        this.handleFeedback = tool.createFeedbackEmitter();
+        this.resizeFeedback = tool.createFeedbackEmitter();
     }
 
     override mouseDown(target: GModelElement, event: MouseEvent): Action[] {
@@ -147,93 +150,132 @@ export class ChangeBoundsListener extends DragAwareMouseListener implements ISel
             return [];
         }
         // check if we have a resize handle (only single-selection)
-        if (this.activeResizeElement && target instanceof SResizeHandle) {
-            this.activeResizeHandle = target;
-        } else {
-            this.setActiveResizeElement(target);
-        }
+        this.updateResizeElement(target, event);
+        return [];
+    }
+
+    protected updateResizeElement(target: GModelElement, event?: MouseEvent): boolean {
+        this.activeResizeHandle = target instanceof GResizeHandle ? target : undefined;
+        this.activeResizeElement = this.activeResizeHandle?.parent ?? this.findResizeElement(target);
         if (this.activeResizeElement) {
-            this.initPosition(event);
+            if (event) {
+                this.tracker.startTracking();
+            }
+            this.initialBounds = {
+                newSize: this.activeResizeElement.bounds,
+                newPosition: this.activeResizeElement.bounds,
+                elementId: this.activeResizeElement.id
+            };
+            // we trigger the local bounds calculation once to get the correct layout information for reszing
+            // for any sub-sequent calls the layout information will be updated automatically
+            this.tool
+                .createFeedbackEmitter()
+                .add(LocalRequestBoundsAction.create(target.root, [this.activeResizeElement.id]))
+                .submit()
+                .dispose();
+            this.handleFeedback.add(
+                ShowChangeBoundsToolResizeFeedbackAction.create({ elementId: this.activeResizeElement.id }),
+                HideChangeBoundsToolResizeFeedbackAction.create()
+            );
+            this.handleFeedback.submit();
+            return true;
         } else {
-            this.reset();
+            this.disposeResize();
+            return false;
         }
-        return [];
     }
 
-    override mouseMove(target: GModelElement, event: MouseEvent): Action[] {
-        super.mouseMove(target, event);
-        if (this.isMouseDrag && this.activeResizeHandle) {
-            // rely on the FeedbackMoveMouseListener to update the element bounds of selected elements
-            // consider resize handles ourselves
-            const actions: Action[] = [
-                cursorFeedbackAction(this.activeResizeHandle.isNwSeResize() ? CursorCSS.RESIZE_NWSE : CursorCSS.RESIZE_NESW),
-                applyCssClasses(this.activeResizeHandle, ChangeBoundsListener.CSS_CLASS_ACTIVE)
-            ];
-            const positionUpdate = this.pointPositionUpdater.updatePosition(
-                target,
-                event,
-                getDirectionFrom(this.activeResizeHandle.location)
-            );
-            if (positionUpdate) {
-                const resizeActions = this.handleResizeOnClient(positionUpdate);
-                actions.push(...resizeActions);
+    protected findResizeElement(target: GModelElement): ResizableModelElement | undefined {
+        // check if we have a selected, moveable element (multi-selection allowed)
+        // but only allow one element to have the element resize handles
+        return findParentByFeature(target, isResizable);
+    }
+
+    protected override draggingMouseMove(target: GModelElement, event: MouseEvent): Action[] {
+        // rely on the FeedbackMoveMouseListener to update the element bounds of selected elements
+        // consider resize handles ourselves
+        if (this.activeResizeHandle && this.tracker.isTracking()) {
+            const resize = this.tracker.resizeElements(this.activeResizeHandle, { snap: event, symmetric: event, restrict: event });
+            const resizeAction = this.resizeBoundsAction(resize);
+            if (resizeAction.bounds.length > 0) {
+                this.resizeFeedback.add(resizeAction, () => this.resetBounds());
+                this.tracker.updateTrackingPosition(resize.handleMove.moveVector);
+                this.addResizeFeedback(resize, target, event);
+                this.resizeFeedback.submit();
             }
-            this.tool.registerFeedback(actions, this);
         }
-        return [];
+        return super.draggingMouseMove(target, event);
     }
 
-    override draggingMouseUp(target: GModelElement, _event: MouseEvent): Action[] {
-        if (this.pointPositionUpdater.isLastDragPositionUndefined()) {
-            this.resetPosition();
-            return [];
-        }
-        const actions: Action[] = [];
+    protected resizeBoundsAction(resize: TrackedResize): SetBoundsFeedbackAction {
+        // we do not want to resize elements beyond their valid size, not even for feedback, as the next layout cycle usually corrects this
+        const elementResizes = resize.elementResizes.filter(elementResize => elementResize.valid.size);
+        return SetBoundsFeedbackAction.create(elementResizes.map(elementResize => this.toElementAndBounds(elementResize)));
+    }
+
+    protected toElementAndBounds(elementResize: TrackedElementResize): ElementAndBounds {
+        return {
+            elementId: elementResize.element.id,
+            newSize: elementResize.toBounds,
+            newPosition: elementResize.toBounds
+        };
+    }
+
+    protected addResizeFeedback(resize: TrackedResize, target: GModelElement, event: MouseEvent): void {
+        this.tool.changeBoundsManager.addResizeFeedback(this.resizeFeedback, resize, target, event);
+    }
+
+    protected resetBounds(): Action[] {
+        // reset the bounds to the initial bounds and ensure that we do not show helper line feedback anymore (MoveFinishedEventAction)
+        return this.initialBounds
+            ? [SetBoundsFeedbackAction.create([this.initialBounds]), MoveFinishedEventAction.create()]
+            : [MoveFinishedEventAction.create()];
+    }
 
+    override draggingMouseUp(target: GModelElement, event: MouseEvent): Action[] {
+        const actions: Action[] = [];
         if (this.activeResizeHandle) {
-            // Resize
-            actions.push(...this.handleResize(this.activeResizeHandle));
+            actions.push(...this.handleResizeOnServer(this.activeResizeHandle));
         } else {
-            // Move
+            // since the move feedback is handled by another class we just see whether there is something to move
             actions.push(...this.handleMoveOnServer(target));
         }
-        this.resetPosition();
-        this.tool.deregisterFeedback(this, [cursorFeedbackAction(CursorCSS.DEFAULT)]);
+        this.disposeResize({ keepHandles: true });
         return actions;
     }
 
+    override nonDraggingMouseUp(element: GModelElement, event: MouseEvent): Action[] {
+        this.disposeResize({ keepHandles: true });
+        return super.nonDraggingMouseUp(element, event);
+    }
+
     protected handleMoveOnServer(target: GModelElement): Action[] {
         const operations: Operation[] = [];
+        const elementToMove = this.getElementsToMove(target);
+        operations.push(...this.handleMoveElementsOnServer(elementToMove));
+        operations.push(...this.handleMoveRoutingPointsOnServer(elementToMove));
+        return operations.length > 0 ? [CompoundOperation.create(operations)] : [];
+    }
 
-        operations.push(...this.handleMoveElementsOnServer(target));
-        operations.push(...this.handleMoveRoutingPointsOnServer(target));
-        if (operations.length > 0) {
-            return [CompoundOperation.create(operations)];
-        }
-        return operations;
+    protected getElementsToMove(target: GModelElement): SelectableBoundsAware[] {
+        const selectedElements = getMatchingElements(target.index, isNonRoutableSelectedMovableBoundsAware);
+        const selectionSet: Set<BoundsAwareModelElement> = new Set(selectedElements);
+        return selectedElements.filter(element => this.isValidMove(element, selectionSet));
     }
 
-    protected handleMoveElementsOnServer(target: GModelElement): Operation[] {
-        const result: Operation[] = [];
-        const newBounds: ElementAndBounds[] = [];
-        const selectedElements: (GModelElement & BoundsAware)[] = [];
-        forEachElement(target.index, isNonRoutableSelectedMovableBoundsAware, element => {
-            selectedElements.push(element);
-        });
-
-        const selectionSet: Set<GModelElement & BoundsAware> = new Set(selectedElements);
-        selectedElements
-            .filter(element => !this.isChildOfSelected(selectionSet, element))
-            .map(element => this.createElementAndBounds(element))
-            .forEach(bounds => newBounds.push(...bounds));
-
-        if (newBounds.length > 0) {
-            result.push(ChangeBoundsOperation.create(newBounds));
-        }
-        return result;
+    protected handleMoveElementsOnServer(elementsToMove: SelectableBoundsAware[]): Operation[] {
+        const newBounds = elementsToMove.map(toElementAndBounds);
+        return newBounds.length > 0 ? [ChangeBoundsOperation.create(newBounds)] : [];
+    }
+
+    protected isValidMove(element: BoundsAwareModelElement, selectedElements: Set<BoundsAwareModelElement> = new Set()): boolean {
+        return this.tool.changeBoundsManager.hasValidPosition(element) && !this.isChildOfSelected(selectedElements, element);
     }
 
     protected isChildOfSelected(selectedElements: Set<GModelElement>, element: GModelElement): boolean {
+        if (selectedElements.size === 0) {
+            return false;
+        }
         while (element instanceof GChildElement) {
             element = element.parent;
             if (selectedElements.has(element)) {
@@ -243,12 +285,12 @@ export class ChangeBoundsListener extends DragAwareMouseListener implements ISel
         return false;
     }
 
-    protected handleMoveRoutingPointsOnServer(target: GModelElement): Operation[] {
+    protected handleMoveRoutingPointsOnServer(elementsToMove: SelectableBoundsAware[]): Operation[] {
         const newRoutingPoints: ElementAndRoutingPoints[] = [];
         const routerRegistry = this.tool.edgeRouterRegistry;
         if (routerRegistry) {
             //  If client routing is enabled -> delegate routing points of connected edges to server
-            forEachElement(target.index, isNonRoutableSelectedMovableBoundsAware, element => {
+            elementsToMove.forEach(element => {
                 if (element instanceof GConnectableElement) {
                     element.incomingEdges
                         .map(connectable => calcElementAndRoutingPoints(connectable, routerRegistry))
@@ -262,217 +304,63 @@ export class ChangeBoundsListener extends DragAwareMouseListener implements ISel
         return newRoutingPoints.length > 0 ? [ChangeRoutingPointsOperation.create(newRoutingPoints)] : [];
     }
 
-    protected handleResize(activeResizeHandle: SResizeHandle): Action[] {
-        const actions: Action[] = [];
-        actions.push(cursorFeedbackAction(CursorCSS.DEFAULT));
-        actions.push(deleteCssClasses(activeResizeHandle, ChangeBoundsListener.CSS_CLASS_ACTIVE));
-        const resizeElement = findParentByFeature(activeResizeHandle, isResizable);
-        if (this.isActiveResizeElement(resizeElement)) {
-            this.createChangeBoundsAction(resizeElement).forEach(action => actions.push(action));
-        }
-        return actions;
-    }
-
-    selectionChanged(root: GModelRoot, selectedElements: string[]): void {
-        if (this.activeResizeElement) {
-            if (selectedElements.includes(this.activeResizeElement.id)) {
-                // our active element is still selected, nothing to do
-                return;
-            }
-
-            // try to find some other selected element and mark that active
-            for (const elementId of selectedElements.reverse()) {
-                const element = root.index.getById(elementId);
-                if (element && this.setActiveResizeElement(element)) {
-                    return;
-                }
-            }
-            this.reset();
-        }
-    }
-
-    protected setActiveResizeElement(target: GModelElement): boolean {
-        // check if we have a selected, moveable element (multi-selection allowed)
-        const moveableElement = findParentByFeature(target, isBoundsAwareMoveable);
-        if (isSelected(moveableElement)) {
-            // only allow one element to have the element resize handles
-            this.activeResizeElement = moveableElement;
-            if (isResizable(this.activeResizeElement)) {
-                this.tool.registerFeedback(
-                    [ShowChangeBoundsToolResizeFeedbackAction.create(this.activeResizeElement.id)],
-                    this.activeResizeElement
-                );
-            }
-            return true;
-        }
-        return false;
-    }
-
-    protected isActiveResizeElement(element?: GModelElement): element is GParentElement & BoundsAware {
-        return element !== undefined && this.activeResizeElement !== undefined && element.id === this.activeResizeElement.id;
-    }
-
-    protected initPosition(event: MouseEvent): void {
-        this.pointPositionUpdater.updateLastDragPosition(event);
-        if (this.activeResizeHandle) {
-            const resizeElement = findParentByFeature(this.activeResizeHandle, isResizable);
-            this.initialBounds = {
-                x: resizeElement!.bounds.x,
-                y: resizeElement!.bounds.y,
-                width: resizeElement!.bounds.width,
-                height: resizeElement!.bounds.height
-            };
-        }
-    }
-
-    dispose(): void {
-        this.reset(true);
-    }
-
-    protected reset(resetBounds = false): void {
-        this.resetFeedback(resetBounds);
-        this.resetPosition();
-    }
-
-    protected resetFeedback(resetBounds = false): void {
-        const resetFeedback: Action[] = [];
-        if (this.activeResizeElement && isResizable(this.activeResizeElement)) {
-            if (this.initialBounds && this.activeResizeHandle && resetBounds) {
-                // we only reset the bounds if an active resize operation was cancelled due to the tool being disabled
-                resetFeedback.push(
-                    SetBoundsFeedbackAction.create([
-                        {
-                            elementId: this.activeResizeElement.id,
-                            newPosition: this.initialBounds,
-                            newSize: this.initialBounds
-                        }
-                    ])
-                );
+    protected handleResizeOnServer(activeResizeHandle: GResizeHandle): Action[] {
+        if (this.initialBounds && this.isValidResize(activeResizeHandle.parent)) {
+            const elementAndBounds = toElementAndBounds(activeResizeHandle.parent);
+            if (!this.initialBounds.newPosition || !elementAndBounds.newPosition) {
+                return [];
             }
-            this.tool.deregisterFeedback(this.activeResizeElement, [HideChangeBoundsToolResizeFeedbackAction.create()]);
-        }
-        resetFeedback.push(cursorFeedbackAction(CursorCSS.DEFAULT));
-        this.tool.deregisterFeedback(this, resetFeedback);
-    }
-
-    protected resetPosition(): void {
-        this.activeResizeHandle = undefined;
-        this.pointPositionUpdater.resetPosition();
-    }
-
-    protected handleResizeOnClient(positionUpdate: Point): Action[] {
-        if (!this.activeResizeHandle) {
-            return [];
-        }
-
-        const resizeElement = findParentByFeature(this.activeResizeHandle, isResizable);
-        if (this.isActiveResizeElement(resizeElement)) {
-            switch (this.activeResizeHandle.location) {
-                case ResizeHandleLocation.TopLeft:
-                    return this.handleTopLeftResize(resizeElement, positionUpdate);
-                case ResizeHandleLocation.TopRight:
-                    return this.handleTopRightResize(resizeElement, positionUpdate);
-                case ResizeHandleLocation.BottomLeft:
-                    return this.handleBottomLeftResize(resizeElement, positionUpdate);
-                case ResizeHandleLocation.BottomRight:
-                    return this.handleBottomRightResize(resizeElement, positionUpdate);
+            if (
+                !Point.equals(this.initialBounds.newPosition, elementAndBounds.newPosition) ||
+                !Dimension.equals(this.initialBounds.newSize, elementAndBounds.newSize)
+            ) {
+                // UX: we do not want the element positions to be reset to their start as they will be moved to their start and
+                // only afterwards moved by the move action again, leading to a ping-pong movement.
+                // We therefore clear our element map so that they cannot be reset.
+                this.initialBounds = undefined;
+                return [ChangeBoundsOperation.create([elementAndBounds])];
             }
         }
         return [];
     }
 
-    protected handleTopLeftResize(resizeElement: GParentElement & Resizable, positionUpdate: Point): Action[] {
-        return this.createSetBoundsAction(
-            resizeElement,
-            resizeElement.bounds.x + positionUpdate.x,
-            resizeElement.bounds.y + positionUpdate.y,
-            resizeElement.bounds.width - positionUpdate.x,
-            resizeElement.bounds.height - positionUpdate.y
-        );
-    }
-
-    protected handleTopRightResize(resizeElement: GParentElement & Resizable, positionUpdate: Point): Action[] {
-        return this.createSetBoundsAction(
-            resizeElement,
-            resizeElement.bounds.x,
-            resizeElement.bounds.y + positionUpdate.y,
-            resizeElement.bounds.width + positionUpdate.x,
-            resizeElement.bounds.height - positionUpdate.y
-        );
-    }
-
-    protected handleBottomLeftResize(resizeElement: GParentElement & Resizable, positionUpdate: Point): Action[] {
-        return this.createSetBoundsAction(
-            resizeElement,
-            resizeElement.bounds.x + positionUpdate.x,
-            resizeElement.bounds.y,
-            resizeElement.bounds.width - positionUpdate.x,
-            resizeElement.bounds.height + positionUpdate.y
-        );
+    protected isValidResize(element: BoundsAwareModelElement): boolean {
+        return this.tool.changeBoundsManager.isValid(element);
     }
 
-    protected handleBottomRightResize(resizeElement: GParentElement & Resizable, positionUpdate: Point): Action[] {
-        return this.createSetBoundsAction(
-            resizeElement,
-            resizeElement.bounds.x,
-            resizeElement.bounds.y,
-            resizeElement.bounds.width + positionUpdate.x,
-            resizeElement.bounds.height + positionUpdate.y
-        );
-    }
-
-    protected createChangeBoundsAction(element: GModelElement & BoundsAware): Action[] {
-        if (this.isValidBoundChange(element, element.bounds, element.bounds)) {
-            return [ChangeBoundsOperation.create([toElementAndBounds(element)])];
-        } else if (this.initialBounds) {
-            const actions: Action[] = [];
-            if (this.tool.movementRestrictor) {
-                actions.push(removeMovementRestrictionFeedback(element, this.tool.movementRestrictor));
-            }
-            actions.push(
-                SetBoundsFeedbackAction.create([{ elementId: element.id, newPosition: this.initialBounds, newSize: this.initialBounds }])
-            );
-            return actions;
-        }
-        return [];
-    }
-
-    protected createElementAndBounds(element: GModelElement & BoundsAware): ElementAndBounds[] {
-        if (this.isValidBoundChange(element, element.bounds, element.bounds)) {
-            return [toElementAndBounds(element)];
+    selectionChanged(root: GModelRoot, selectedElements: string[]): void {
+        if (this.activeResizeElement && selectedElements.includes(this.activeResizeElement.id)) {
+            // our active element is still selected, nothing to do
+            return;
         }
-        return [];
-    }
-
-    protected createSetBoundsAction(element: GModelElement & BoundsAware, x: number, y: number, width: number, height: number): Action[] {
-        const newPosition = { x, y };
-        const newSize = { width, height };
-        const result: Action[] = [];
 
-        if (this.isValidBoundChange(element, newPosition, newSize)) {
-            if (this.tool.movementRestrictor) {
-                result.push(removeMovementRestrictionFeedback(element, this.tool.movementRestrictor));
-            }
-            result.push(SetBoundsFeedbackAction.create([{ elementId: element.id, newPosition, newSize }]));
-        } else if (this.isValidSize(element, newSize)) {
-            if (this.tool.movementRestrictor) {
-                result.push(createMovementRestrictionFeedback(element, this.tool.movementRestrictor));
+        // try to find some other selected element and mark that active
+        for (const elementId of selectedElements.reverse()) {
+            const element = root.index.getById(elementId);
+            if (element && this.updateResizeElement(element)) {
+                return;
             }
-            result.push(SetBoundsFeedbackAction.create([{ elementId: element.id, newPosition, newSize }]));
         }
-
-        return result;
+        this.dispose();
     }
 
-    protected isValidBoundChange(element: GModelElement & BoundsAware, newPosition: Point, newSize: Dimension): boolean {
-        return this.isValidSize(element, newSize) && this.isValidMove(element, newPosition);
+    protected isActiveResizeElement(element?: GModelElement): element is GParentElement & BoundsAware {
+        return element !== undefined && this.activeResizeElement !== undefined && element.id === this.activeResizeElement.id;
     }
 
-    protected isValidSize(element: GModelElement & BoundsAware, size: Dimension): boolean {
-        return isValidSize(element, size);
+    protected disposeResize(opts: { keepHandles: boolean } = { keepHandles: false }): void {
+        if (!opts.keepHandles) {
+            this.handleFeedback.dispose();
+        }
+        this.resizeFeedback.dispose();
+        this.tracker.dispose();
+        this.activeResizeElement = undefined;
+        this.activeResizeHandle = undefined;
+        this.initialBounds = undefined;
     }
 
-    protected isValidMove(element: GModelElement & BoundsAware, newPosition: Point): boolean {
-        return isValidMove(element, newPosition, this.tool.movementRestrictor);
+    override dispose(): void {
+        this.disposeResize();
+        super.dispose();
     }
 }