@eclipse-glsp/client 2.2.0-next.336 → 2.2.0-next.337

package/src/features/debug/debug-bounds-decorator.tsx

@@ -15,7 +15,7 @@
  ********************************************************************************/
 /* eslint-disable max-len */
 
-import { Bounds, GModelElement, IVNodePostprocessor, Point, TYPES, isDecoration, isSizeable, setClass, svg } from '@eclipse-glsp/sprotty';
+import { Bounds, GModelElement, IVNodePostprocessor, Point, isDecoration, isSizeable, setClass, svg } from '@eclipse-glsp/sprotty';
 import { inject, injectable, optional } from 'inversify';
 import { VNode } from 'snabbdom';
 import { GGraph } from '../../model';
@@ -29,7 +29,7 @@ export const CSS_DEBUG_BOUNDS = 'debug-bounds';
 
 @injectable()
 export class DebugBoundsDecorator implements IVNodePostprocessor {
-    @inject(TYPES.IDebugManager) @optional() protected debugManager?: DebugManager;
+    @inject(DebugManager) @optional() protected debugManager?: DebugManager;
 
     decorate(vnode: VNode, element: GModelElement): VNode {
         if (!this.debugManager?.isDebugEnabled) {
@@ -87,7 +87,7 @@ export class DebugBoundsDecorator implements IVNodePostprocessor {
     }
 
     protected renderTopLeftCorner(element: BoundsAwareModelElement): VNode {
-        const position = Bounds.topLeft(element.bounds);
+        const position = Bounds.position(element.bounds);
         const topLeft = Bounds.topLeft(element.bounds);
         const corner = Point.subtract(topLeft, position);
         return (
@@ -104,7 +104,7 @@ export class DebugBoundsDecorator implements IVNodePostprocessor {
     }
 
     protected renderTopRightCorner(element: BoundsAwareModelElement): VNode {
-        const position = Bounds.topLeft(element.bounds);
+        const position = Bounds.position(element.bounds);
         const topRight = Bounds.topRight(element.bounds);
         const corner = Point.subtract(topRight, position);
         return (
@@ -121,7 +121,7 @@ export class DebugBoundsDecorator implements IVNodePostprocessor {
     }
 
     protected renderBottomLeftCorner(element: BoundsAwareModelElement): VNode {
-        const position = Bounds.topLeft(element.bounds);
+        const position = Bounds.position(element.bounds);
         const bottomLeft = Bounds.bottomLeft(element.bounds);
         const corner = Point.subtract(bottomLeft, position);
         return (
@@ -138,7 +138,7 @@ export class DebugBoundsDecorator implements IVNodePostprocessor {
     }
 
     protected renderBottomRightCorner(element: BoundsAwareModelElement): VNode {
-        const position = Bounds.topLeft(element.bounds);
+        const position = Bounds.position(element.bounds);
         const bottomRight = Bounds.bottomRight(element.bounds);
         const corner = Point.subtract(bottomRight, position);
         return (
@@ -156,7 +156,7 @@ export class DebugBoundsDecorator implements IVNodePostprocessor {
 
     protected renderCenter(element: BoundsAwareModelElement): VNode {
         const bounds = element.bounds;
-        const position = Bounds.topLeft(bounds);
+        const position = Bounds.position(bounds);
         const center = Bounds.center(bounds);
         const corner = Point.subtract(center, position);
         return (

package/src/features/debug/debug-module.ts

@@ -25,7 +25,7 @@ export const debugModule = new FeatureModule((bind, unbind, isBound, rebind) =>
 
     configureCommand(context, EnableDebugModeCommand);
 
-    bindAsService(bind, TYPES.IDebugManager, DebugManager);
+    bind(DebugManager).toSelf().inSingletonScope();
     configureActionHandler(context, EnableDebugModeAction.KIND, DebugManager);
 
     bindAsService(context, TYPES.IVNodePostprocessor, DebugBoundsDecorator);

package/src/features/element-template/mouse-tracking-element-position-listener.ts

@@ -17,16 +17,12 @@
 import { Action, Dimension, GModelElement, MoveAction, Point, isBoundsAware, isMoveable } from '@eclipse-glsp/sprotty';
 import { DragAwareMouseListener } from '../../base/drag-aware-mouse-listener';
 import { CSS_HIDDEN, ModifyCSSFeedbackAction } from '../../base/feedback/css-feedback';
-import { FeedbackEmitter } from '../../base/feedback/feeback-emitter';
+import { FeedbackEmitter } from '../../base/feedback/feedback-emitter';
 import { MoveableElement, getAbsolutePosition } from '../../utils';
-import {
-    CSS_RESIZE_MODE,
-    ChangeBoundsManager,
-    ChangeBoundsTracker,
-    FeedbackAwareTool,
-    MoveFinishedEventAction,
-    TrackedElementMove
-} from '../tools';
+import { FeedbackAwareTool } from '../tools/base-tools';
+import { ChangeBoundsManager } from '../tools/change-bounds/change-bounds-manager';
+import { MoveFinishedEventAction } from '../tools/change-bounds/change-bounds-tool-feedback';
+import { ChangeBoundsTracker, TrackedMove } from '../tools/change-bounds/change-bounds-tracker';
 
 export interface PositioningTool extends FeedbackAwareTool {
     readonly changeBoundsManager: ChangeBoundsManager;
@@ -51,16 +47,16 @@ export class MouseTrackingElementPositionListener extends DragAwareMouseListener
         return !element || !isMoveable(element) ? undefined : element;
     }
 
-    override mouseMove(target: GModelElement, event: MouseEvent): Action[] {
-        super.mouseMove(target, event);
-        const element = this.getTrackedElement(target, event);
+    override mouseMove(ctx: GModelElement, event: MouseEvent): Action[] {
+        super.mouseMove(ctx, event);
+        const element = this.getTrackedElement(ctx, event);
         if (!element) {
             return [];
         }
         if (!this.tracker.isTracking()) {
-            this.initialize(element, target, event);
+            this.initialize(element, ctx, event);
         }
-        const move = this.tracker.moveElements([element], { snap: event, restrict: event, validate: true });
+        const move = this.tracker.moveElements([element], { snap: event, restrict: event });
         const elementMove = move.elementMoves[0];
         if (!elementMove) {
             return [];
@@ -71,7 +67,7 @@ export class MouseTrackingElementPositionListener extends DragAwareMouseListener
             MoveAction.create([{ elementId: this.elementId, toPosition: elementMove.toPosition }], { animate: false }),
             MoveFinishedEventAction.create()
         );
-        this.addMoveFeeback(elementMove);
+        this.addMoveFeedback(move, ctx, event);
         this.moveGhostFeedback.submit();
         this.tracker.updateTrackingPosition(elementMove.moveVector);
         return [];
@@ -89,13 +85,9 @@ export class MouseTrackingElementPositionListener extends DragAwareMouseListener
             : mousePosition;
     }
 
-    protected addMoveFeeback(move: TrackedElementMove): void {
-        this.tool.changeBoundsManager.addRestrictionFeedback(this.moveGhostFeedback, move);
-        this.moveGhostFeedback.add(ModifyCSSFeedbackAction.create({ elements: [move.element.id], remove: [CSS_HIDDEN] }));
-        this.moveGhostFeedback.add(
-            ModifyCSSFeedbackAction.create({ add: [CSS_RESIZE_MODE] }),
-            ModifyCSSFeedbackAction.create({ remove: [CSS_RESIZE_MODE] })
-        );
+    protected addMoveFeedback(move: TrackedMove, ctx: GModelElement, event: MouseEvent): void {
+        this.moveGhostFeedback.add(ModifyCSSFeedbackAction.create({ elements: [this.elementId], remove: [CSS_HIDDEN] }));
+        this.tool.changeBoundsManager.addMoveFeedback(this.moveGhostFeedback, move, ctx, event);
     }
 
     override dispose(): void {

package/src/features/grid/grid-module.ts

@@ -14,7 +14,7 @@
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
 
-import { FeatureModule, TYPES, bindAsService, configureActionHandler, configureCommand } from '@eclipse-glsp/sprotty';
+import { FeatureModule, TYPES, configureActionHandler, configureCommand } from '@eclipse-glsp/sprotty';
 import '../../../css/grid.css';
 import { GridManager } from './grid-manager';
 import { ShowGridAction, ShowGridCommand } from './grid-model';
@@ -27,7 +27,7 @@ export const gridModule = new FeatureModule((bind, unbind, isBound, rebind) => {
 
     configureCommand(context, ShowGridCommand);
 
-    bindAsService(bind, TYPES.IGridManager, GridManager);
+    bind(GridManager).toSelf().inSingletonScope();
     configureActionHandler(context, ShowGridAction.KIND, GridManager);
 
     bind(TYPES.ISnapper).to(GridSnapper);

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

@@ -30,6 +30,7 @@ import { FeedbackEmitter } from '../../base';
 import { IFeedbackActionDispatcher } from '../../base/feedback/feedback-action-dispatcher';
 import { ISelectionListener, SelectionService } from '../../base/selection-service';
 import { SetBoundsFeedbackAction } from '../bounds/set-bounds-feedback-command';
+import { ResizeHandleLocation, SResizeHandle } from '../change-bounds/model';
 import { Grid } from '../grid';
 import { MoveFinishedEventAction, MoveInitializedEventAction } from '../tools/change-bounds/change-bounds-tool-feedback';
 import {
@@ -165,32 +166,87 @@ export class HelperLineManager implements IActionHandler, ISelectionListener, IH
         if (!isSnap) {
             return 0;
         }
-        return direction === Direction.Left || direction === Direction.Right
-            ? this.options.minimumMoveDelta.x
-            : this.options.minimumMoveDelta.y;
+        const minimumMoveDelta = this.options.minimumMoveDelta;
+        return direction === Direction.Left || direction === Direction.Right ? minimumMoveDelta.x : minimumMoveDelta.y;
     }
 
-    getMinimumMoveVector(element: GModelElement, isSnap: boolean, directions: Direction[]): Vector | undefined {
+    getMinimumMoveVector(element: GModelElement, isSnap: boolean, move: Direction[]): Vector | undefined {
         if (!isSnap) {
             return undefined;
         }
 
-        const helperLines = element.root.children.filter(child => isHelperLine(child)) as HelperLine[];
-        if (helperLines.length === 0) {
+        const state = this.getHelperLineState(element);
+        if (state.helperLines.length === 0) {
             return undefined;
         }
 
         const minimum: Writable<Vector> = { ...Vector.ZERO };
-        if (directions.includes(Direction.Left) && helperLines.some(line => line.isLeft || line.isCenter)) {
+        const resize =
+            element instanceof SResizeHandle
+                ? ResizeHandleLocation.direction(element.location)
+                : [Direction.Left, Direction.Right, Direction.Up, Direction.Down];
+
+        if ((state.types.left || state.types.center) && move.includes(Direction.Left) && resize.includes(Direction.Left)) {
             minimum.x = this.getMinimumMoveDelta(element, isSnap, Direction.Left);
-        } else if (directions.includes(Direction.Right) && helperLines.some(line => line.isRight || line.isCenter)) {
+        } else if ((state.types.right || state.types.center) && move.includes(Direction.Right) && resize.includes(Direction.Right)) {
             minimum.x = this.getMinimumMoveDelta(element, isSnap, Direction.Right);
         }
-        if (directions.includes(Direction.Up) && helperLines.some(line => line.isTop || line.isMiddle)) {
+        if ((state.types.top || state.types.middle) && move.includes(Direction.Up) && resize.includes(Direction.Up)) {
             minimum.y = this.getMinimumMoveDelta(element, isSnap, Direction.Up);
-        } else if (directions.includes(Direction.Down) && helperLines.some(line => line.isBottom || line.isMiddle)) {
+        } else if ((state.types.bottom || state.types.middle) && move.includes(Direction.Down) && resize.includes(Direction.Down)) {
             minimum.y = this.getMinimumMoveDelta(element, isSnap, Direction.Down);
         }
         return Vector.isZero(minimum) ? undefined : minimum;
     }
+
+    protected getHelperLineState(element: GModelElement): HelperLineState {
+        const helperLines = element.root.children.filter(isHelperLine) || [];
+        const types = {
+            left: false,
+            right: false,
+            top: false,
+            bottom: false,
+            center: false,
+            middle: false
+        };
+        for (const line of helperLines) {
+            switch (line.lineType) {
+                case HelperLineType.Left:
+                case HelperLineType.LeftRight:
+                    types.left = true;
+                    break;
+                case HelperLineType.Right:
+                case HelperLineType.RightLeft:
+                    types.right = true;
+                    break;
+                case HelperLineType.Top:
+                case HelperLineType.TopBottom:
+                    types.top = true;
+                    break;
+                case HelperLineType.Bottom:
+                case HelperLineType.BottomTop:
+                    types.bottom = true;
+                    break;
+                case HelperLineType.Center:
+                    types.center = true;
+                    break;
+                case HelperLineType.Middle:
+                    types.middle = true;
+                    break;
+            }
+        }
+        return { helperLines, types };
+    }
+}
+
+export interface HelperLineState {
+    helperLines: HelperLine[];
+    types: {
+        left: boolean;
+        right: boolean;
+        top: boolean;
+        bottom: boolean;
+        center: boolean;
+        middle: boolean;
+    };
 }

package/src/features/hints/model.ts

@@ -24,7 +24,12 @@ export interface Containable {
     isContainableElement(input: GModelElement | GModelElementSchema | string): boolean;
 }
 
-export function isContainable(element: GModelElement): element is GModelElement & Containable {
+/**
+ * A union type for all elements that can contain other elements.
+ */
+export type ContainerElement = GModelElement & Containable;
+
+export function isContainable(element: GModelElement): element is ContainerElement {
     return element.hasFeature(containerFeature);
 }
 

package/src/features/hints/type-hint-provider.spec.ts

@@ -37,7 +37,7 @@ import { Container } from 'inversify';
 import * as sinon from 'sinon';
 import { FeedbackEmitter } from '../../base';
 import { GLSPActionDispatcher } from '../../base/action-dispatcher';
-import { FeedbackActionDispatcher } from '../../base/feedback/feedback-action-dispatcher';
+import { FeedbackActionDispatcher } from '../../base/feedback/feedback-action-dispatcher-default';
 import { GEdge } from '../../model';
 import { isResizable } from '../change-bounds/model';
 import { isReconnectable } from '../reconnect/model';

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

@@ -13,7 +13,7 @@
  *
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
-import { Action, BringToFrontAction, GModelElement, SelectAction, SelectMouseListener, TYPES } from '@eclipse-glsp/sprotty';
+import { Action, BringToFrontAction, GModelElement, SelectAction, SelectMouseListener } from '@eclipse-glsp/sprotty';
 import { inject, injectable, optional } from 'inversify';
 import { Ranked } from '../../base/ranked';
 import { SelectableElement } from '../../utils';
@@ -28,7 +28,7 @@ import { ChangeBoundsManager } from '../tools';
 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;
+    @inject(ChangeBoundsManager) @optional() readonly changeBoundsManager?: ChangeBoundsManager;
 
     protected override handleSelectTarget(
         selectableTarget: SelectableElement,

package/src/features/tool-palette/tool-palette.ts

@@ -26,7 +26,6 @@ import {
     SetContextActions,
     SetModelAction,
     SetUIExtensionVisibilityAction,
-    TYPES,
     TriggerNodeCreationAction,
     UpdateModelAction,
     codiconCSSClasses,
@@ -78,11 +77,11 @@ export class ToolPalette extends AbstractUIExtension implements IActionHandler,
     @inject(FocusTracker)
     protected focusTracker: FocusTracker;
 
-    @inject(TYPES.IGridManager)
+    @inject(GridManager)
     @optional()
     protected gridManager?: GridManager;
 
-    @inject(TYPES.IDebugManager)
+    @inject(DebugManager)
     @optional()
     protected debugManager?: DebugManager;
 

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

@@ -17,8 +17,8 @@ import { Action, Disposable, DisposableCollection, IActionHandler, TYPES } from
 import { inject, injectable } from 'inversify';
 import { GLSPActionDispatcher } from '../../base/action-dispatcher';
 import { EditorContextService } from '../../base/editor-context-service';
-import { FeedbackEmitter } from '../../base/feedback/feeback-emitter';
 import { IFeedbackActionDispatcher, IFeedbackEmitter, MaybeActions } from '../../base/feedback/feedback-action-dispatcher';
+import { FeedbackEmitter } from '../../base/feedback/feedback-emitter';
 import { EnableToolsAction, Tool } from '../../base/tool-manager/tool';
 import { GLSPKeyTool } from '../../base/view/key-tool';
 import { GLSPMouseTool } from '../../base/view/mouse-tool';

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

@@ -28,19 +28,32 @@ import {
     isLocateable
 } from '@eclipse-glsp/sprotty';
 import { inject, injectable, optional } from 'inversify';
-import { FeedbackEmitter } from '../../../base';
+import {
+    CursorCSS,
+    FeedbackEmitter,
+    ModifyCSSFeedbackAction,
+    applyCssClasses,
+    cursorFeedbackAction,
+    deleteCssClasses,
+    toggleCssClasses
+} from '../../../base';
 import { isValidMove, minDimensions } from '../../../utils';
 import { LayoutAware } from '../../bounds/layout-data';
 import {
     IMovementRestrictor,
     ResizeHandleLocation,
+    SResizeHandle,
     movementRestrictionFeedback,
     removeMovementRestrictionFeedback
 } from '../../change-bounds';
+import { GridManager } from '../../grid';
 import { IHelperLineManager } from '../../helper-lines';
-import { ChangeBoundsTracker, TrackedElementMove } from './change-bounds-tracker';
+import { InsertIndicator } from '../node-creation/insert-indicator';
+import { ChangeBoundsTracker, TrackedElementMove, TrackedElementResize, TrackedMove, TrackedResize } from './change-bounds-tracker';
 
 export const CSS_RESIZE_MODE = 'resize-mode';
+export const CSS_RESTRICTED_RESIZE = 'resize-not-allowed';
+export const CSS_ACTIVE_HANDLE = 'active';
 
 @injectable()
 export class ChangeBoundsManager {
@@ -48,7 +61,8 @@ export class ChangeBoundsManager {
         @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
+        @optional() @inject(TYPES.IHelperLineManager) readonly helperLineManager?: IHelperLineManager,
+        @optional() @inject(GridManager) protected gridManager?: GridManager
     ) {}
 
     unsnapModifier(): KeyboardModifier | undefined {
@@ -102,7 +116,7 @@ export class ChangeBoundsManager {
     }
 
     restrictMovement(element: GModelElement, movement: Movement): Movement {
-        const minimumMovement = this.helperLineManager?.getMinimumMoveVector(element, true, movement.direction);
+        const minimumMovement = this.getMinimumMovement(element, movement);
         if (!minimumMovement) {
             return movement;
         }
@@ -116,23 +130,67 @@ export class ChangeBoundsManager {
         return Point.move(movement.from, targetPosition);
     }
 
-    addRestrictionFeedback(feedback: FeedbackEmitter, move: TrackedElementMove): FeedbackEmitter {
+    protected getMinimumMovement(element: GModelElement, movement: Movement): Vector | undefined {
+        return element instanceof InsertIndicator && this.gridManager
+            ? this.gridManager.grid
+            : this.helperLineManager?.getMinimumMoveVector(element, true, movement.direction);
+    }
+
+    addMoveFeedback(feedback: FeedbackEmitter, trackedMove: TrackedMove, ctx?: GModelElement, event?: MouseEvent): FeedbackEmitter {
+        // cursor feedback on graph
+        feedback.add(cursorFeedbackAction(CursorCSS.MOVE), cursorFeedbackAction(CursorCSS.DEFAULT));
+
+        // restriction feedback on each element
+        trackedMove.elementMoves.forEach(move => this.addMoveRestrictionFeedback(feedback, move, ctx, event));
+
+        return feedback;
+    }
+
+    addResizeFeedback(feedback: FeedbackEmitter, resize: TrackedResize, ctx?: GModelElement, event?: MouseEvent): FeedbackEmitter {
+        // graph feedback
+        feedback.add(
+            ModifyCSSFeedbackAction.create({ add: [CSS_RESIZE_MODE] }),
+            ModifyCSSFeedbackAction.create({ remove: [CSS_RESIZE_MODE] })
+        );
+
+        // cursor feedback on graph
+        const cursorClass = SResizeHandle.getCursorCss(resize.handleMove.element);
+        feedback.add(cursorFeedbackAction(cursorClass), cursorFeedbackAction(CursorCSS.DEFAULT));
+
+        // handle feedback
+        const handle = resize.handleMove.element;
+        feedback.add(applyCssClasses(handle, CSS_ACTIVE_HANDLE), deleteCssClasses(handle, CSS_ACTIVE_HANDLE));
+        feedback.add(toggleCssClasses(handle, !resize.valid.size, CSS_RESTRICTED_RESIZE), deleteCssClasses(handle, CSS_RESTRICTED_RESIZE));
+
+        // restriction feedback on each element
+        resize.elementResizes.forEach(elementResize => {
+            this.addMoveRestrictionFeedback(feedback, elementResize, ctx, event);
+            feedback.add(
+                toggleCssClasses(elementResize.element, !elementResize.valid.size, CSS_RESTRICTED_RESIZE),
+                deleteCssClasses(elementResize.element, CSS_RESTRICTED_RESIZE)
+            );
+        });
+        return feedback;
+    }
+
+    addMoveRestrictionFeedback(
+        feedback: FeedbackEmitter,
+        change: TrackedElementResize | TrackedElementMove,
+        ctx?: GModelElement,
+        event?: MouseEvent
+    ): FeedbackEmitter {
         if (this.movementRestrictor) {
+            const valid = TrackedElementMove.is(change) ? change.valid : change.valid.move;
             feedback.add(
-                movementRestrictionFeedback(move.element, this.movementRestrictor!, move.valid),
-                removeMovementRestrictionFeedback(move.element, this.movementRestrictor!)
+                movementRestrictionFeedback(change.element, this.movementRestrictor, valid),
+                removeMovementRestrictionFeedback(change.element, this.movementRestrictor)
             );
         }
         return feedback;
     }
 
     defaultResizeLocations(): ResizeHandleLocation[] {
-        return [
-            ResizeHandleLocation.TopLeft,
-            ResizeHandleLocation.TopRight,
-            ResizeHandleLocation.BottomRight,
-            ResizeHandleLocation.BottomLeft
-        ];
+        return ResizeHandleLocation.CORNERS;
     }
 
     useSymmetricResize(arg: MouseEvent | KeyboardEvent | any): boolean {

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

@@ -71,7 +71,7 @@ export class ShowChangeBoundsToolResizeFeedbackCommand extends FeedbackCommand {
     static readonly KIND = ShowChangeBoundsToolResizeFeedbackAction.KIND;
 
     @inject(TYPES.Action) protected action: ShowChangeBoundsToolResizeFeedbackAction;
-    @inject(TYPES.IChangeBoundsManager) protected changeBoundsManager: ChangeBoundsManager;
+    @inject(ChangeBoundsManager) protected changeBoundsManager: ChangeBoundsManager;
 
     execute(context: CommandExecutionContext): CommandReturn {
         const index = context.root.index;
@@ -81,7 +81,10 @@ export class ShowChangeBoundsToolResizeFeedbackCommand extends FeedbackCommand {
         if (this.action.elementId) {
             const resizeElement = index.getById(this.action.elementId);
             if (resizeElement && isResizable(resizeElement)) {
-                addResizeHandles(resizeElement, this.action.resizeLocations ?? this.changeBoundsManager.defaultResizeLocations());
+                addResizeHandles(
+                    resizeElement,
+                    this.action.resizeLocations ?? resizeElement.resizeLocations ?? this.changeBoundsManager.defaultResizeLocations()
+                );
             }
         }
         return context.root;

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

@@ -23,7 +23,7 @@ import { SResizeHandleView } from './view';
 
 export const changeBoundsToolModule = new FeatureModule((bind, unbind, isBound, rebind) => {
     const context = { bind, unbind, isBound, rebind };
-    bindAsService(context, TYPES.IChangeBoundsManager, ChangeBoundsManager);
+    bind(ChangeBoundsManager).toSelf().inSingletonScope();
     bindAsService(context, TYPES.IDefaultTool, ChangeBoundsTool);
     configureCommand(context, ShowChangeBoundsToolResizeFeedbackCommand);
     configureCommand(context, HideChangeBoundsToolResizeFeedbackCommand);

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

@@ -19,7 +19,7 @@ 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 { FeedbackEmitter } from '../../../base/feedback/feedback-emitter';
 import { MoveableElement, filter, getElements, isNonRoutableSelectedMovableBoundsAware, removeDescendants } from '../../../utils';
 import { SResizeHandle } from '../../change-bounds/model';
 import { ChangeBoundsTool } from './change-bounds-tool';
@@ -128,7 +128,7 @@ export class FeedbackMoveMouseListener extends DragAwareMouseListener {
         // cancel any pending move
         this.pendingMoveInitialized?.cancel();
         this.moveFeedback.add(this.createMoveAction(move), () => this.resetElementPositions(target));
-        this.addMovementFeedback(move, target, event);
+        this.addMoveFeedback(move, target, event);
         this.tracker.updateTrackingPosition(move);
         this.moveFeedback.submit();
         return [];
@@ -142,12 +142,8 @@ export class FeedbackMoveMouseListener extends DragAwareMouseListener {
         );
     }
 
-    protected addMovementFeedback(trackedMove: TrackedMove, ctx: GModelElement, event: MouseEvent): void {
-        // cursor feedback
-        this.moveFeedback.add(cursorFeedbackAction(CursorCSS.MOVE), cursorFeedbackAction(CursorCSS.DEFAULT));
-
-        // restriction feedback
-        trackedMove.elementMoves.forEach(move => this.tool.changeBoundsManager.addRestrictionFeedback(this.moveFeedback, move));
+    protected addMoveFeedback(trackedMove: TrackedMove, ctx: GModelElement, event: MouseEvent): void {
+        this.tool.changeBoundsManager.addMoveFeedback(this.moveFeedback, trackedMove, ctx, event);
     }
 
     protected initializeElementsToMove(root: GModelRoot): void {