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

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

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

@@ -37,11 +37,18 @@ import {
     TYPES,
     findParentByFeature
 } from '@eclipse-glsp/sprotty';
+import { CSS_RESIZE_MODE, ChangeBoundsManager, ChangeBoundsTracker, TrackedElementResize, TrackedResize } from '..';
 import { DragAwareMouseListener } from '../../../base/drag-aware-mouse-listener';
-import { CursorCSS, applyCssClasses, cursorFeedbackAction, deleteCssClasses } from '../../../base/feedback/css-feedback';
+import {
+    CursorCSS,
+    ModifyCSSFeedbackAction,
+    applyCssClasses,
+    cursorFeedbackAction,
+    deleteCssClasses,
+    toggleCssClasses
+} from '../../../base/feedback/css-feedback';
 import { FeedbackEmitter } from '../../../base/feedback/feeback-emitter';
 import { ISelectionListener, SelectionService } from '../../../base/selection-service';
-import { isValidMove, isValidSize } from '../../../utils';
 import {
     BoundsAwareModelElement,
     ResizableModelElement,
@@ -51,16 +58,13 @@ import {
     isNonRoutableSelectedMovableBoundsAware,
     toElementAndBounds
 } from '../../../utils/gmodel-util';
-import { SetBoundsFeedbackAction } from '../../bounds';
-import { PointPositionUpdater } from '../../change-bounds';
-import { ResizeHandleLocation, SResizeHandle, isResizable } from '../../change-bounds/model';
+import { LocalRequestBoundsAction, SetBoundsFeedbackAction } from '../../bounds';
+import { SResizeHandle, isResizable } from '../../change-bounds/model';
 import {
     IMovementRestrictor,
-    createMovementRestrictionFeedback,
+    movementRestrictionFeedback,
     removeMovementRestrictionFeedback
 } from '../../change-bounds/movement-restrictor';
-import { PositionSnapper } from '../../change-bounds/position-snapper';
-import { getDirectionFrom } from '../../helper-lines';
 import { BaseEditTool } from '../base-tools';
 import {
     HideChangeBoundsToolResizeFeedbackAction,
@@ -89,7 +93,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(TYPES.IChangeBoundsManager) readonly changeBoundsManager: ChangeBoundsManager;
 
     get id(): string {
         return ChangeBoundsTool.ID;
@@ -115,6 +119,10 @@ export class ChangeBoundsTool extends BaseEditTool {
         );
     }
 
+    createChangeBoundsTracker(): ChangeBoundsTracker {
+        return this.changeBoundsManager.createTracker();
+    }
+
     protected createMoveMouseListener(): MouseListener {
         return new FeedbackMoveMouseListener(this);
     }
@@ -124,22 +132,12 @@ export class ChangeBoundsTool extends BaseEditTool {
     }
 }
 
-export interface ValidatedElementAndBounds extends ElementAndBounds {
-    valid: boolean;
-}
-
-export namespace ValidatedElementAndBounds {
-    export function isValid(move: ElementAndBounds): boolean {
-        return (move as ValidatedElementAndBounds).valid ?? true;
-    }
-}
-
-export class ChangeBoundsListener extends DragAwareMouseListener implements ISelectionListener, Disposable {
+export class ChangeBoundsListener extends DragAwareMouseListener implements ISelectionListener {
     static readonly CSS_CLASS_ACTIVE = 'active';
 
     // members for calculating the correct position change
     protected initialBounds: ElementAndBounds | undefined;
-    protected positionUpdater: PointPositionUpdater;
+    protected tracker: ChangeBoundsTracker;
 
     // members for resize mode
     protected activeResizeElement?: ResizableModelElement;
@@ -149,7 +147,7 @@ export class ChangeBoundsListener extends DragAwareMouseListener implements ISel
 
     constructor(protected tool: ChangeBoundsTool) {
         super();
-        this.positionUpdater = new PointPositionUpdater(tool.positionSnapper);
+        this.tracker = tool.createChangeBoundsTracker();
         this.handleFeedback = tool.createFeedbackEmitter();
         this.resizeFeedback = tool.createFeedbackEmitter();
     }
@@ -171,22 +169,28 @@ export class ChangeBoundsListener extends DragAwareMouseListener implements ISel
         this.activeResizeElement = this.activeResizeHandle?.parent ?? this.findResizeElement(target);
         if (this.activeResizeElement) {
             if (event) {
-                this.positionUpdater.updateLastDragPosition(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(this.activeResizeElement.id),
+                ShowChangeBoundsToolResizeFeedbackAction.create({ elementId: this.activeResizeElement.id }),
                 HideChangeBoundsToolResizeFeedbackAction.create()
             );
             this.handleFeedback.submit();
             return true;
         } else {
-            this.positionUpdater.resetPosition();
-            this.handleFeedback.dispose();
+            this.dispose();
             return false;
         }
     }
@@ -200,74 +204,81 @@ export class ChangeBoundsListener extends DragAwareMouseListener implements ISel
     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.positionUpdater.isLastDragPositionUndefined()) {
-            if (!this.initialBounds) {
-                const element = this.activeResizeHandle.parent;
-                this.initialBounds = { elementId: element.id, newSize: element.bounds, newPosition: element.bounds };
-            }
-            const positionUpdate = this.positionUpdater.updatePosition(target, event, getDirectionFrom(this.activeResizeHandle.location));
-            if (positionUpdate) {
-                const resizeActions = this.handleResizeOnClient(positionUpdate).filter(action => action);
-                if (resizeActions.length > 0) {
-                    this.resizeFeedback.add(SetBoundsFeedbackAction.create(resizeActions), () => this.resetBoundsAction());
-                    this.addResizeFeedback(resizeActions, this.activeResizeHandle, target, event);
-                    this.resizeFeedback.submit();
-                }
+        if (this.activeResizeHandle && this.tracker.isTracking()) {
+            const resize = this.tracker.resizeElements(this.activeResizeHandle, { snap: event, symmetric: event, restrict: event });
+            this.addResizeFeedback(resize, target, event);
+            const resizeAction = this.resizeBoundsAction(resize);
+            if (resizeAction.bounds.length > 0) {
+                this.resizeFeedback.add(resizeAction, () => this.resetBounds());
+                this.tracker.updateTrackingPosition(resize.handleMove.moveVector);
+            } else {
+                this.resizeFeedback.add(undefined, () => this.resetBounds());
             }
+            this.resizeFeedback.submit();
         }
         return super.draggingMouseMove(target, event);
     }
 
-    protected filterResizeOnClient(resize: ValidatedElementAndBounds, positionUpdate: Point): boolean {
-        return true;
+    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 addResizeFeedback(
-        resizeActions: ValidatedElementAndBounds[],
-        handle: SResizeHandle,
-        target: GModelElement,
-        event: MouseEvent
-    ): void {
+    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 {
+        const handle = resize.handleMove.element;
         // handle feedback
         this.resizeFeedback.add(
             applyCssClasses(handle, ChangeBoundsListener.CSS_CLASS_ACTIVE),
             deleteCssClasses(handle, ChangeBoundsListener.CSS_CLASS_ACTIVE)
         );
 
+        // graph feedback
+        this.resizeFeedback.add(
+            ModifyCSSFeedbackAction.create({ add: [CSS_RESIZE_MODE] }),
+            ModifyCSSFeedbackAction.create({ remove: [CSS_RESIZE_MODE] })
+        );
+
         // cursor feedback
-        const cursorClass = handle.isNeResize()
-            ? CursorCSS.RESIZE_NE
-            : handle.isNwResize()
-              ? CursorCSS.RESIZE_NW
-              : handle.isSeResize()
-                ? CursorCSS.RESIZE_SE
-                : CursorCSS.RESIZE_SW;
+        const cursorClass = SResizeHandle.getCursorCss(resize.handleMove.element);
         this.resizeFeedback.add(cursorFeedbackAction(cursorClass), cursorFeedbackAction(CursorCSS.DEFAULT));
 
-        // restriction feedback
-        resizeActions.forEach(elementResize => {
-            const element = handle.root.index.getById(elementResize.elementId);
-            if (element && this.tool.movementRestrictor) {
-                if (!elementResize.valid) {
-                    this.resizeFeedback.add(createMovementRestrictionFeedback(element, this.tool.movementRestrictor), () =>
-                        removeMovementRestrictionFeedback(element, this.tool.movementRestrictor!)
-                    );
-                } else {
-                    this.resizeFeedback.add(removeMovementRestrictionFeedback(element, this.tool.movementRestrictor!));
-                }
+        const movementRestrictor = this.tool.changeBoundsManager.movementRestrictor;
+        resize.elementResizes.forEach(elementResize => {
+            if (movementRestrictor) {
+                this.resizeFeedback.add(
+                    movementRestrictionFeedback(elementResize.element, movementRestrictor, elementResize.valid.move),
+                    removeMovementRestrictionFeedback(elementResize.element, movementRestrictor)
+                );
             }
+            this.resizeFeedback.add(
+                toggleCssClasses(elementResize.element, !elementResize.valid.size, 'resize-not-allowed'),
+                deleteCssClasses(elementResize.element, 'resize-not-allowed')
+            );
         });
+        this.resizeFeedback.add(
+            toggleCssClasses(resize.handleMove.element, !resize.valid.size, 'resize-not-allowed'),
+            deleteCssClasses(resize.handleMove.element, 'resize-not-allowed')
+        );
     }
 
-    protected resetBoundsAction(): Action[] {
+    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[] {
-        if (this.positionUpdater.isLastDragPositionUndefined()) {
+    override draggingMouseUp(target: GModelElement, event: MouseEvent): Action[] {
+        if (!this.tracker.isTracking()) {
             return [];
         }
         const actions: Action[] = [];
@@ -296,17 +307,13 @@ export class ChangeBoundsListener extends DragAwareMouseListener implements ISel
         const selectedElements = getMatchingElements(target.index, isNonRoutableSelectedMovableBoundsAware);
         const selectionSet: Set<BoundsAwareModelElement> = new Set(selectedElements);
         const newBounds: ElementAndBounds[] = selectedElements
-            .filter(element => this.isValidElement(element, selectionSet))
+            .filter(element => this.isValidMove(element, selectionSet))
             .map(toElementAndBounds);
         return newBounds.length > 0 ? [ChangeBoundsOperation.create(newBounds)] : [];
     }
 
-    protected isValidElement(element: BoundsAwareModelElement, selectedElements: Set<BoundsAwareModelElement> = new Set()): boolean {
-        return (
-            this.isValidMove(element, element.bounds) &&
-            this.isValidSize(element, element.bounds) &&
-            !this.isChildOfSelected(selectedElements, element)
-        );
+    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 {
@@ -342,7 +349,7 @@ export class ChangeBoundsListener extends DragAwareMouseListener implements ISel
     }
 
     protected handleResizeOnServer(activeResizeHandle: SResizeHandle): Action[] {
-        if (this.isValidElement(activeResizeHandle.parent) && this.initialBounds) {
+        if (this.initialBounds && this.isValidResize(activeResizeHandle.parent)) {
             const elementAndBounds = toElementAndBounds(activeResizeHandle.parent);
             if (!this.initialBounds.newPosition || !elementAndBounds.newPosition) {
                 return [];
@@ -361,6 +368,10 @@ export class ChangeBoundsListener extends DragAwareMouseListener implements ISel
         return [];
     }
 
+    protected isValidResize(element: BoundsAwareModelElement): boolean {
+        return this.tool.changeBoundsManager.isValid(element);
+    }
+
     selectionChanged(root: GModelRoot, selectedElements: string[]): void {
         if (this.activeResizeElement && selectedElements.includes(this.activeResizeElement.id)) {
             // our active element is still selected, nothing to do
@@ -374,88 +385,18 @@ export class ChangeBoundsListener extends DragAwareMouseListener implements ISel
                 return;
             }
         }
-        this.updateResizeElement(root);
-        this.disposeAllButHandles();
+        this.dispose();
     }
 
     protected isActiveResizeElement(element?: GModelElement): element is GParentElement & BoundsAware {
         return element !== undefined && this.activeResizeElement !== undefined && element.id === this.activeResizeElement.id;
     }
 
-    protected handleResizeOnClient(positionUpdate: Point): ValidatedElementAndBounds[] {
-        if (!this.activeResizeHandle) {
-            return [];
-        }
-
-        if (this.isActiveResizeElement(this.activeResizeHandle.parent)) {
-            switch (this.activeResizeHandle.location) {
-                case ResizeHandleLocation.TopLeft:
-                    return this.handleTopLeftResize(this.activeResizeHandle.parent, positionUpdate);
-                case ResizeHandleLocation.TopRight:
-                    return this.handleTopRightResize(this.activeResizeHandle.parent, positionUpdate);
-                case ResizeHandleLocation.BottomLeft:
-                    return this.handleBottomLeftResize(this.activeResizeHandle.parent, positionUpdate);
-                case ResizeHandleLocation.BottomRight:
-                    return this.handleBottomRightResize(this.activeResizeHandle.parent, positionUpdate);
-            }
-        }
-        return [];
-    }
-
-    protected handleTopLeftResize(resizeElement: ResizableModelElement, positionUpdate: Point): ValidatedElementAndBounds[] {
-        return this.createSetBoundsAction(
-            resizeElement,
-            { x: resizeElement.bounds.x + positionUpdate.x, y: resizeElement.bounds.y + positionUpdate.y },
-            { width: resizeElement.bounds.width - positionUpdate.x, height: resizeElement.bounds.height - positionUpdate.y }
-        );
-    }
-
-    protected handleTopRightResize(resizeElement: ResizableModelElement, positionUpdate: Point): ValidatedElementAndBounds[] {
-        return this.createSetBoundsAction(
-            resizeElement,
-            { x: resizeElement.bounds.x, y: resizeElement.bounds.y + positionUpdate.y },
-            { width: resizeElement.bounds.width + positionUpdate.x, height: resizeElement.bounds.height - positionUpdate.y }
-        );
-    }
-
-    protected handleBottomLeftResize(resizeElement: ResizableModelElement, positionUpdate: Point): ValidatedElementAndBounds[] {
-        return this.createSetBoundsAction(
-            resizeElement,
-            { x: resizeElement.bounds.x + positionUpdate.x, y: resizeElement.bounds.y },
-            { width: resizeElement.bounds.width - positionUpdate.x, height: resizeElement.bounds.height + positionUpdate.y }
-        );
-    }
-
-    protected handleBottomRightResize(resizeElement: ResizableModelElement, positionUpdate: Point): ValidatedElementAndBounds[] {
-        return this.createSetBoundsAction(
-            resizeElement,
-            { x: resizeElement.bounds.x, y: resizeElement.bounds.y },
-            { width: resizeElement.bounds.width + positionUpdate.x, height: resizeElement.bounds.height + positionUpdate.y }
-        );
-    }
-
-    protected createSetBoundsAction(element: BoundsAwareModelElement, newPosition: Point, newSize: Dimension): ValidatedElementAndBounds[] {
-        if (!isValidSize(element, newSize)) {
-            // we are not allowing any invalid sizes (breaking min size), not even during client feedback
-            return [];
-        }
-        const valid = this.isValidMove(element, newPosition);
-        return [{ elementId: element.id, newPosition, newSize, valid }];
-    }
-
-    protected isValidSize(element: BoundsAwareModelElement, size: Dimension): boolean {
-        return isValidSize(element, size);
-    }
-
-    protected isValidMove(element: BoundsAwareModelElement, newPosition: Point): boolean {
-        return isValidMove(element, newPosition, this.tool.movementRestrictor);
-    }
-
     protected disposeAllButHandles(): void {
         // We do not dispose the handle feedback as we want to keep showing the handles on selected elements
         // this.handleFeedback.dispose();
         this.resizeFeedback.dispose();
-        this.positionUpdater.resetPosition();
+        this.tracker.dispose();
         this.activeResizeElement = undefined;
         this.activeResizeHandle = undefined;
         this.initialBounds = undefined;