@eclipse-glsp/client 2.2.0-next.329 → 2.2.0-next.330

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

@@ -18,8 +18,8 @@ import {
     Action,
     Dimension,
     Disposable,
+    ElementMove,
     GModelElement,
-    Locateable,
     MoveAction,
     Point,
     isBoundsAware,
@@ -28,8 +28,10 @@ import {
 import { injectable } from 'inversify';
 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 { IFeedbackEmitter } from '../../base/feedback/feedback-action-dispatcher';
 import { Tool } from '../../base/tool-manager/tool';
+import { MoveableElement } from '../../utils';
 import { getAbsolutePosition } from '../../utils/viewpoint-util';
 import {
     IMovementRestrictor,
@@ -39,20 +41,28 @@ import {
 import { PointPositionUpdater } from '../change-bounds/point-position-updater';
 import { PositionSnapper } from '../change-bounds/position-snapper';
 import { useSnap } from '../change-bounds/snap';
+import { MoveFinishedEventAction } from '../tools';
 
 export interface PositioningTool extends Tool {
     readonly positionSnapper: PositionSnapper;
     readonly movementRestrictor?: IMovementRestrictor;
 
+    createFeedbackEmitter(): FeedbackEmitter;
+    /**
+     * @deprecated It is recommended to create a {@link createFeedbackEmitter dedicated emitter} per feedback instead of using the tool.
+     */
     registerFeedback(feedbackActions: Action[], feedbackEmitter?: IFeedbackEmitter, cleanupActions?: Action[]): Disposable;
+    /**
+     * @deprecated It is recommended to create a {@link createFeedbackEmitter dedicated emitter} per feedback and dispose it like that.
+     */
     deregisterFeedback(feedbackEmitter?: IFeedbackEmitter, cleanupActions?: Action[]): void;
 }
 
 @injectable()
 export class MouseTrackingElementPositionListener extends DragAwareMouseListener {
-    currentPosition?: Point;
-
     protected positionUpdater: PointPositionUpdater;
+    protected moveGhostFeedback: FeedbackEmitter;
+    protected currentPosition?: Point;
 
     constructor(
         protected elementId: string,
@@ -61,6 +71,7 @@ export class MouseTrackingElementPositionListener extends DragAwareMouseListener
     ) {
         super();
         this.positionUpdater = new PointPositionUpdater(this.tool.positionSnapper);
+        this.moveGhostFeedback = this.tool.createFeedbackEmitter();
     }
 
     override mouseMove(target: GModelElement, event: MouseEvent): Action[] {
@@ -69,59 +80,48 @@ export class MouseTrackingElementPositionListener extends DragAwareMouseListener
         if (!element || !isMoveable(element)) {
             return [];
         }
-        let targetPosition = this.getTargetPosition(target, event, element);
         if (this.positionUpdater.isLastDragPositionUndefined()) {
-            this.positionUpdater.updateLastDragPosition(targetPosition);
+            this.positionUpdater.updateLastDragPosition(element.position);
         }
-        const delta = this.positionUpdater.updatePosition(element, targetPosition, useSnap(event));
+        const mousePosition = getAbsolutePosition(target, event);
+        const delta = this.positionUpdater.updatePosition(element, mousePosition, useSnap(event));
         if (!delta) {
             return [];
         }
-        targetPosition = this.validateMove(this.currentPosition ?? targetPosition, targetPosition, element, false);
-        const moveGhostElement = MoveAction.create(
-            [
-                {
-                    elementId: element.id,
-                    fromPosition: this.currentPosition,
-                    toPosition: targetPosition
-                }
-            ],
-            { animate: false, finished: false }
-        );
-        this.currentPosition = targetPosition;
-        this.tool.registerFeedback([moveGhostElement], this);
-        return element.cssClasses?.includes(CSS_HIDDEN)
-            ? [ModifyCSSFeedbackAction.create({ elements: [element.id], remove: [CSS_HIDDEN] })]
-            : [];
-    }
-
-    protected getTargetPosition(target: GModelElement, event: MouseEvent, element: GModelElement & Locateable): Point {
-        let targetPosition = getAbsolutePosition(target, event);
-        if (this.cursorPosition === 'middle' && isBoundsAware(element)) {
-            targetPosition = Point.subtract(targetPosition, Dimension.center(element.bounds));
-        }
-        return targetPosition;
+        const toPosition = this.getElementTargetPosition(mousePosition, element, event);
+        const elementMove = { elementId: element.id, toPosition: toPosition };
+        this.addMoveFeeback(element, elementMove);
+        this.currentPosition = toPosition;
+        // since we are moving a ghost element that is feedback-only and will be removed anyway,
+        // we just send a MoveFinishedEventAction instead of reseting the position with a MoveAction and the finished flag set to true.
+        this.moveGhostFeedback.add(MoveAction.create([elementMove], { animate: false }), MoveFinishedEventAction.create()).submit();
+        return [];
     }
 
-    protected snap(position: Point, element: GModelElement, isSnap = true): Point {
-        return this.tool.positionSnapper.snapPosition(position, element, isSnap);
+    protected getElementTargetPosition(mousePosition: Point, element: MoveableElement, event: MouseEvent): Point {
+        const unsnappedPosition =
+            this.cursorPosition === 'middle' && isBoundsAware(element)
+                ? Point.subtract(mousePosition, Dimension.center(element.bounds))
+                : mousePosition;
+        return this.tool.positionSnapper.snapPosition(unsnappedPosition, element, useSnap(event));
     }
 
-    protected validateMove(startPosition: Point, toPosition: Point, element: GModelElement, isFinished: boolean): Point {
-        let newPosition = toPosition;
+    protected addMoveFeeback(element: MoveableElement, elementMove: ElementMove): void {
         if (this.tool.movementRestrictor) {
-            const valid = this.tool.movementRestrictor.validate(element, toPosition);
-            let action;
-            if (!valid) {
-                action = createMovementRestrictionFeedback(element, this.tool.movementRestrictor);
-                if (isFinished) {
-                    newPosition = startPosition;
-                }
+            if (!this.tool.movementRestrictor.validate(element, elementMove.toPosition)) {
+                this.moveGhostFeedback.add(
+                    createMovementRestrictionFeedback(element, this.tool.movementRestrictor),
+                    removeMovementRestrictionFeedback(element, this.tool.movementRestrictor)
+                );
             } else {
-                action = removeMovementRestrictionFeedback(element, this.tool.movementRestrictor);
+                this.moveGhostFeedback.add(removeMovementRestrictionFeedback(element, this.tool.movementRestrictor));
             }
-            this.tool.registerFeedback([action], this, [removeMovementRestrictionFeedback(element, this.tool.movementRestrictor)]);
         }
-        return newPosition;
+        this.moveGhostFeedback.add(ModifyCSSFeedbackAction.create({ elements: [element.id], remove: [CSS_HIDDEN] }));
+    }
+
+    override dispose(): void {
+        this.moveGhostFeedback.dispose();
+        super.dispose();
     }
 }

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

@@ -13,18 +13,9 @@
  *
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
-import {
-    Action,
-    DisposableCollection,
-    GModelElement,
-    GModelRoot,
-    IActionHandler,
-    MoveAction,
-    Point,
-    SetBoundsAction,
-    TYPES
-} from '@eclipse-glsp/sprotty';
+import { Action, GModelElement, GModelRoot, IActionHandler, MoveAction, Point, SetBoundsAction, TYPES } from '@eclipse-glsp/sprotty';
 import { inject, injectable, optional, postConstruct } from 'inversify';
+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';
@@ -95,10 +86,11 @@ export class HelperLineManager implements IActionHandler, ISelectionListener, IH
     @optional() @inject(TYPES.IHelperLineOptions) protected userOptions?: IHelperLineOptions;
 
     protected options: Required<IHelperLineOptions>;
-    protected feedback: DisposableCollection = new DisposableCollection();
+    protected feedback: FeedbackEmitter;
 
     @postConstruct()
     protected init(): void {
+        this.feedback = this.feedbackDispatcher.createEmitter();
         this.options = { ...DEFAULT_HELPER_LINE_OPTIONS, ...this.userOptions };
         this.selectionService.onSelectionChanged(change =>
             this.selectionChanged(change.root, change.selectedElements, change.deselectedElements)
@@ -118,9 +110,7 @@ export class HelperLineManager implements IActionHandler, ISelectionListener, IH
     }
 
     protected handleMoveInitializedAction(_action: MoveInitializedEventAction): void {
-        this.feedback.dispose();
-        const feedback = this.createHelperLineFeedback(this.selectionService.getSelectedElementIDs());
-        this.feedback.push(this.feedbackDispatcher.registerFeedback(this, [feedback], [RemoveHelperLinesFeedbackAction.create()]));
+        this.submitHelperLineFeedback();
     }
 
     protected handleMoveFinishedAction(_action: MoveFinishedEventAction): void {
@@ -129,22 +119,23 @@ export class HelperLineManager implements IActionHandler, ISelectionListener, IH
 
     protected handleMoveAction(action: MoveAction): void {
         if (!action.finished) {
-            const elementIds = action.moves.map(move => move.elementId);
-            const feedback = this.createHelperLineFeedback(elementIds);
-            this.feedback.push(this.feedbackDispatcher.registerFeedback(this, [feedback], [RemoveHelperLinesFeedbackAction.create()]));
+            this.submitHelperLineFeedback(action.moves.map(move => move.elementId));
         } else {
             this.feedback.dispose();
         }
     }
 
+    protected submitHelperLineFeedback(elementIds: string[] = this.selectionService.getSelectedElementIDs()): void {
+        const feedback = this.createHelperLineFeedback(elementIds);
+        this.feedback.add(feedback, [RemoveHelperLinesFeedbackAction.create()]).submit();
+    }
+
     protected createHelperLineFeedback(elementIds: string[]): DrawHelperLinesFeedbackAction {
         return DrawHelperLinesFeedbackAction.create({ elementIds, ...this.options });
     }
 
     protected handleSetBoundsAction(action: SetBoundsAction | SetBoundsFeedbackAction): void {
-        const elementIds = action.bounds.map(bound => bound.elementId);
-        const feedback = this.createHelperLineFeedback(elementIds);
-        this.feedback.push(this.feedbackDispatcher.registerFeedback(this, [feedback], [RemoveHelperLinesFeedbackAction.create()]));
+        this.submitHelperLineFeedback(action.bounds.map(bound => bound.elementId));
     }
 
     selectionChanged(root: Readonly<GModelRoot>, selectedElements: string[], deselectedElements?: string[] | undefined): void {

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

@@ -35,6 +35,7 @@ import {
 import { expect } from 'chai';
 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 { GEdge } from '../../model';
@@ -45,7 +46,9 @@ import { ApplyTypeHintsAction, ApplyTypeHintsCommand, ITypeHintProvider, TypeHin
 describe('TypeHintProvider', () => {
     const container = new Container();
     container.bind(GLSPActionDispatcher).toConstantValue(sinon.createStubInstance(GLSPActionDispatcher));
-    container.bind(TYPES.IFeedbackActionDispatcher).toConstantValue(sinon.createStubInstance(FeedbackActionDispatcher));
+    const stub = sinon.createStubInstance(FeedbackActionDispatcher);
+    stub.createEmitter.returns(new FeedbackEmitter(stub));
+    container.bind(TYPES.IFeedbackActionDispatcher).toConstantValue(stub);
     const typeHintProvider = container.resolve(TypeHintProvider);
 
     describe('getShapeTypeHint', () => {

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

@@ -35,8 +35,9 @@ import {
     isConnectable,
     moveFeature
 } from '@eclipse-glsp/sprotty';
-import { inject, injectable } from 'inversify';
+import { inject, injectable, postConstruct } from 'inversify';
 
+import { FeedbackEmitter } from '../../base';
 import { GLSPActionDispatcher } from '../../base/action-dispatcher';
 import { IFeedbackActionDispatcher } from '../../base/feedback/feedback-action-dispatcher';
 import { FeedbackCommand } from '../../base/feedback/feedback-command';
@@ -204,15 +205,21 @@ export class TypeHintProvider implements IActionHandler, ITypeHintProvider, IDia
     @inject(GLSPActionDispatcher)
     protected actionDispatcher: GLSPActionDispatcher;
 
+    protected typeHintsFeedback: FeedbackEmitter;
     protected shapeHints: Map<string, ShapeTypeHint> = new Map();
     protected edgeHints: Map<string, EdgeTypeHint> = new Map();
 
+    @postConstruct()
+    protected init(): void {
+        this.typeHintsFeedback = this.feedbackActionDispatcher.createEmitter();
+    }
+
     handle(action: SetTypeHintsAction): void {
         this.shapeHints.clear();
         this.edgeHints.clear();
         action.shapeHints.forEach(hint => this.shapeHints.set(hint.elementTypeId, hint));
         action.edgeHints.forEach(hint => this.edgeHints.set(hint.elementTypeId, hint));
-        this.feedbackActionDispatcher.registerFeedback(this, [ApplyTypeHintsAction.create()]);
+        this.typeHintsFeedback.add(ApplyTypeHintsAction.create()).submit();
     }
 
     getShapeTypeHint(input: GModelElement | GModelElementSchema | string): ShapeTypeHint | undefined {

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

@@ -13,8 +13,9 @@
  *
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
-import { Action, BringToFrontAction, GModelElement, SelectAction, SelectMouseListener, Selectable } from '@eclipse-glsp/sprotty';
+import { Action, BringToFrontAction, GModelElement, SelectAction, SelectMouseListener } from '@eclipse-glsp/sprotty';
 import { Ranked } from '../../base/ranked';
+import { SelectableElement } from '../../utils';
 
 /**
  * Ranked select mouse listener that is executed before default mouse listeners when using the RankedMouseTool.
@@ -24,7 +25,7 @@ export class RankedSelectMouseListener extends SelectMouseListener implements Ra
     rank: number = Ranked.DEFAULT_RANK - 100; /* we want to be executed before all default mouse listeners */
 
     protected override handleSelectTarget(
-        selectableTarget: GModelElement & Selectable,
+        selectableTarget: SelectableElement,
         deselectedElements: GModelElement[],
         event: MouseEvent
     ): (Action | Promise<Action>)[] {
@@ -40,7 +41,7 @@ export class RankedSelectMouseListener extends SelectMouseListener implements Ra
         return result;
     }
 
-    protected override handleDeselectTarget(selectableTarget: GModelElement & Selectable, event: MouseEvent): (Action | Promise<Action>)[] {
+    protected override handleDeselectTarget(selectableTarget: SelectableElement, event: MouseEvent): (Action | Promise<Action>)[] {
         const result: Action[] = [];
         result.push(SelectAction.create({ selectedElementsIDs: [], deselectedElementsIDs: [selectableTarget.id] }));
         return result;

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

@@ -13,11 +13,12 @@
  *
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
-import { inject, injectable } from 'inversify';
 import { Action, Disposable, DisposableCollection, IActionHandler, TYPES } from '@eclipse-glsp/sprotty';
+import { inject, injectable } from 'inversify';
 import { GLSPActionDispatcher } from '../../base/action-dispatcher';
 import { EditorContextService } from '../../base/editor-context-service';
-import { IFeedbackActionDispatcher, IFeedbackEmitter } from '../../base/feedback/feedback-action-dispatcher';
+import { FeedbackEmitter } from '../../base/feedback/feeback-emitter';
+import { IFeedbackActionDispatcher, IFeedbackEmitter, MaybeActions } from '../../base/feedback/feedback-action-dispatcher';
 import { EnableToolsAction, Tool } from '../../base/tool-manager/tool';
 import { GLSPKeyTool } from '../../base/view/key-tool';
 import { GLSPMouseTool } from '../../base/view/mouse-tool';
@@ -47,8 +48,12 @@ export abstract class BaseEditTool implements Tool {
         return true;
     }
 
-    dispatchActions(actions: Action[]): void {
-        this.actionDispatcher.dispatchAll(actions);
+    dispatchActions(actions: Action[]): Promise<void> {
+        return this.actionDispatcher.dispatchAll(actions);
+    }
+
+    createFeedbackEmitter(): FeedbackEmitter {
+        return this.feedbackDispatcher.createEmitter();
     }
 
     /**
@@ -59,9 +64,10 @@ export abstract class BaseEditTool implements Tool {
      * @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?: Action[]): Disposable {
-        return this.feedbackDispatcher.registerFeedback(feedbackEmitter ?? this, feedbackActions, cleanupActions);
+    registerFeedback(feedbackActions: Action[], feedbackEmitter: IFeedbackEmitter = this, cleanupActions?: MaybeActions): Disposable {
+        return this.feedbackDispatcher.registerFeedback(feedbackEmitter, feedbackActions, cleanupActions);
     }
 
     /**
@@ -70,9 +76,10 @@ export abstract class BaseEditTool implements Tool {
      *
      * @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?: Action[]): void {
-        this.feedbackDispatcher.deregisterFeedback(feedbackEmitter ?? this, cleanupActions);
+    deregisterFeedback(feedbackEmitter: IFeedbackEmitter = this, cleanupActions?: MaybeActions): void {
+        this.feedbackDispatcher.deregisterFeedback(feedbackEmitter, cleanupActions);
     }
 }
 

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

@@ -13,35 +13,13 @@
  *
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
-import {
-    Action,
-    CommandExecutionContext,
-    CommandReturn,
-    Disposable,
-    ElementMove,
-    GChildElement,
-    GModelElement,
-    GModelRoot,
-    MoveAction,
-    Point,
-    TYPES,
-    findParentByFeature,
-    hasStringProp,
-    isMoveable,
-    isSelectable
-} from '@eclipse-glsp/sprotty';
+import { Action, CommandExecutionContext, CommandReturn, TYPES, hasStringProp } from '@eclipse-glsp/sprotty';
 import { inject, injectable } from 'inversify';
 
-import { DebouncedFunc, debounce } from 'lodash';
-import { DragAwareMouseListener } from '../../../base/drag-aware-mouse-listener';
-import { CursorCSS, cursorFeedbackAction } from '../../../base/feedback/css-feedback';
 import { FeedbackCommand } from '../../../base/feedback/feedback-command';
 import { OptionalAction } from '../../../base/model/glsp-model-source';
 import { forEachElement } from '../../../utils/gmodel-util';
-import { SResizeHandle, addResizeHandles, isResizable, removeResizeHandles } from '../../change-bounds/model';
-import { createMovementRestrictionFeedback, removeMovementRestrictionFeedback } from '../../change-bounds/movement-restrictor';
-import { PointPositionUpdater } from '../../change-bounds/point-position-updater';
-import { ChangeBoundsTool } from './change-bounds-tool';
+import { addResizeHandles, isResizable, removeResizeHandles } from '../../change-bounds/model';
 
 export interface ShowChangeBoundsToolResizeFeedbackAction extends Action {
     kind: typeof ShowChangeBoundsToolResizeFeedbackAction.KIND;
@@ -89,13 +67,11 @@ export class ShowChangeBoundsToolResizeFeedbackCommand extends FeedbackCommand {
     execute(context: CommandExecutionContext): CommandReturn {
         const index = context.root.index;
 
-        forEachElement(index, isResizable, removeResizeHandles);
+        forEachElement(index, isResizable, element => element.id !== this.action.elementId && removeResizeHandles(element));
 
-        if (this.action.elementId) {
-            const resizeElement = index.getById(this.action.elementId);
-            if (resizeElement && isResizable(resizeElement)) {
-                addResizeHandles(resizeElement);
-            }
+        const resizeElement = index.getById(this.action.elementId);
+        if (resizeElement && isResizable(resizeElement)) {
+            addResizeHandles(resizeElement);
         }
         return context.root;
     }
@@ -145,205 +121,3 @@ export namespace MoveFinishedEventAction {
         return OptionalAction.mark({ kind: KIND });
     }
 }
-
-/**
- * This mouse listener provides visual feedback for moving by sending client-side
- * `MoveAction`s while elements are selected and dragged. This will also update
- * their bounds, which is important, as it is not only required for rendering
- * 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 {
-    protected rootElement?: GModelRoot;
-    protected positionUpdater;
-    protected elementId2startPos = new Map<string, Point>();
-    protected pendingMoveInitialized?: DebouncedFunc<() => void>;
-    protected moveInitialized = false;
-
-    constructor(protected tool: ChangeBoundsTool) {
-        super();
-        this.positionUpdater = new PointPositionUpdater(tool.positionSnapper);
-    }
-
-    override mouseDown(target: GModelElement, event: MouseEvent): Action[] {
-        if (event.button === 0 && !(target instanceof SResizeHandle)) {
-            const moveable = findParentByFeature(target, isMoveable);
-            if (moveable !== undefined && !(target instanceof SResizeHandle)) {
-                this.positionUpdater.updateLastDragPosition(event);
-                this.scheduleMoveInitialized();
-            } else {
-                this.positionUpdater.resetPosition();
-            }
-            this._isMouseDrag = false;
-        }
-        return [];
-    }
-
-    protected scheduleMoveInitialized(): void {
-        this.moveInitialized = false;
-        this.pendingMoveInitialized?.cancel();
-        this.pendingMoveInitialized = debounce(() => {
-            this.tool.registerFeedback([MoveInitializedEventAction.create()], this);
-            this.pendingMoveInitialized = undefined;
-            this.moveInitialized = true;
-        }, 750);
-        this.pendingMoveInitialized();
-    }
-
-    override mouseMove(target: GModelElement, event: MouseEvent): Action[] {
-        const result: Action[] = [];
-        if (event.buttons === 0) {
-            this.mouseUp(target, event);
-        } else if (!this.positionUpdater.isLastDragPositionUndefined()) {
-            if (this.elementId2startPos.size === 0) {
-                this.collectStartPositions(target.root);
-            }
-            this._isMouseDrag = true;
-            const moveAction = this.getElementMoves(target, event, false);
-            if (moveAction) {
-                this.pendingMoveInitialized?.cancel();
-                result.push(moveAction);
-                result.push(cursorFeedbackAction(CursorCSS.MOVE));
-                this.tool.registerFeedback(result, this);
-            }
-        }
-        return [];
-    }
-
-    protected collectStartPositions(root: GModelRoot): void {
-        this.rootElement = root;
-        const selectedElements = root.index.all().filter(element => isSelectable(element) && element.selected);
-        const elementsSet = new Set(selectedElements);
-        selectedElements
-            .filter(element => !this.isChildOfSelected(elementsSet, element))
-            .forEach(element => {
-                if (isMoveable(element)) {
-                    this.elementId2startPos.set(element.id, element.position);
-                }
-            });
-    }
-
-    protected isChildOfSelected(selectedElements: Set<GModelElement>, element: GModelElement): boolean {
-        while (element instanceof GChildElement) {
-            element = element.parent;
-            if (selectedElements.has(element)) {
-                return true;
-            }
-        }
-        return false;
-    }
-
-    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);
-        if (elementMoves.length > 0) {
-            return MoveAction.create(elementMoves, { animate: false, finished });
-        } else {
-            return undefined;
-        }
-    }
-
-    protected getElementMovesForDelta(target: GModelElement, delta: Point, finished: boolean): ElementMove[] {
-        const elementMoves: ElementMove[] = [];
-        this.elementId2startPos.forEach((startPosition, elementId) => {
-            const element = target.root.index.getById(elementId);
-            if (element) {
-                if (isMoveable(element)) {
-                    const targetPosition = Point.add(element.position, delta);
-                    const toPosition = this.validateMove(startPosition, targetPosition, element, finished);
-                    elementMoves.push({ elementId: element.id, fromPosition: element.position, toPosition });
-                }
-            }
-        });
-        return elementMoves;
-    }
-
-    protected validateMove(startPosition: Point, toPosition: Point, element: GModelElement, isFinished: boolean): Point {
-        let newPosition = toPosition;
-        if (this.tool.movementRestrictor) {
-            const valid = this.tool.movementRestrictor.validate(element, toPosition);
-            let action;
-            if (!valid) {
-                action = createMovementRestrictionFeedback(element, this.tool.movementRestrictor);
-                if (isFinished) {
-                    newPosition = startPosition;
-                }
-            } else {
-                action = removeMovementRestrictionFeedback(element, this.tool.movementRestrictor);
-            }
-            this.tool.registerFeedback([action], this);
-        }
-        return newPosition;
-    }
-
-    override mouseEnter(target: GModelElement, event: MouseEvent): Action[] {
-        if (target instanceof GModelRoot && event.buttons === 0 && this.positionUpdater.isLastDragPositionUndefined()) {
-            this.mouseUp(target, event);
-        }
-        return [];
-    }
-
-    override nonDraggingMouseUp(element: GModelElement, event: MouseEvent): Action[] {
-        this.reset(true);
-        return [];
-    }
-
-    override draggingMouseUp(target: GModelElement, event: MouseEvent): Action[] {
-        const result: Action[] = [];
-        if (this.positionUpdater.isLastDragPositionUndefined()) {
-            this.reset(true);
-            return result;
-        } else {
-            const moveAction = this.getElementMoves(target, event, true);
-            if (moveAction) {
-                result.push(moveAction);
-            }
-            const resetFeedback: Action[] = [];
-            if (this.tool.movementRestrictor) {
-                resetFeedback.push(removeMovementRestrictionFeedback(target, this.tool.movementRestrictor));
-            }
-            resetFeedback.push(cursorFeedbackAction(CursorCSS.DEFAULT));
-            this.tool.deregisterFeedback(this, resetFeedback);
-        }
-        this.reset();
-        return result;
-    }
-
-    protected resetMoveFeedback(): ElementMove[] {
-        const elementMoves: ElementMove[] = [];
-        this.elementId2startPos.forEach((startPosition, elementId) => {
-            const element = this.rootElement!.index.getById(elementId);
-            if (element) {
-                if (isMoveable(element)) {
-                    elementMoves.push({ elementId: element.id, fromPosition: element.position, toPosition: startPosition });
-                }
-            }
-        });
-        return elementMoves;
-    }
-
-    protected reset(resetFeedback = false): void {
-        this.pendingMoveInitialized?.cancel();
-        if (this.rootElement && resetFeedback) {
-            const elementMoves: ElementMove[] = this.resetMoveFeedback();
-            if (elementMoves.length > 0) {
-                const moveAction = MoveAction.create(elementMoves, { animate: false, finished: true });
-                this.tool.deregisterFeedback(this, [moveAction]);
-            }
-        } else if (resetFeedback && this.moveInitialized) {
-            this.tool.deregisterFeedback(this, [MoveFinishedEventAction.create()]);
-        }
-        this.positionUpdater.resetPosition();
-        this._isMouseDrag = false;
-        this.moveInitialized = false;
-        this.rootElement = undefined;
-        this.elementId2startPos.clear();
-    }
-
-    dispose(): void {
-        this.reset(true);
-    }
-}

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

@@ -14,6 +14,7 @@
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
 import { FeatureModule, TYPES, bindAsService, configureCommand, configureView } from '@eclipse-glsp/sprotty';
+import '../../../../css/change-bounds.css';
 import { SResizeHandle } from '../../change-bounds/model';
 import { ChangeBoundsTool } from './change-bounds-tool';
 import { HideChangeBoundsToolResizeFeedbackCommand, ShowChangeBoundsToolResizeFeedbackCommand } from './change-bounds-tool-feedback';