@eclipse-glsp/client 1.1.0-next.697cc23.237 → 1.1.0-next.69a77b0.259

package/src/features/tools/base-glsp-creation-tool.ts

@@ -0,0 +1,40 @@
+/********************************************************************************
+ * Copyright (c) 2023 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
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the Eclipse
+ * Public License v. 2.0 are satisfied: GNU General Public License, version 2
+ * with the GNU Classpath Exception which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ ********************************************************************************/
+import { injectable } from 'inversify';
+import { Action, EnableToolsAction, IActionHandler } from '~glsp-sprotty';
+import { BaseGLSPTool } from './base-glsp-tool';
+
+@injectable()
+export abstract class BaseGLSPCreationTool<T extends Action> extends BaseGLSPTool implements IActionHandler {
+    protected abstract isTriggerAction: (obj: any) => obj is T;
+    protected triggerAction: T;
+
+    handle(action: Action): Action | void {
+        if (this.isTriggerAction(action)) {
+            this.triggerAction = action;
+            return EnableToolsAction.create([this.id]);
+        }
+    }
+
+    override enable(): void {
+        if (this.triggerAction === undefined) {
+            throw new TypeError(`Could not enable tool ${this.id}. The triggerAction cannot be undefined.`);
+        }
+        this.doEnable();
+    }
+
+    protected abstract doEnable(): void;
+}

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

@@ -1,5 +1,5 @@
 /********************************************************************************
- * Copyright (c) 2020-2022 EclipseSource and others.
+ * Copyright (c) 2020-2023 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
@@ -13,25 +13,29 @@
  *
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
-import { Action } from '@eclipse-glsp/protocol';
 import { inject, injectable } from 'inversify';
-import { IActionDispatcher, KeyTool } from 'sprotty';
+import { Action, Disposable, DisposableCollection, IActionDispatcher, TYPES } from '~glsp-sprotty';
 import { EditorContextService } from '../../base/editor-context-service';
+import { IFeedbackActionDispatcher, IFeedbackEmitter } from '../../base/feedback/feedback-action-dispatcher';
 import { GLSPTool } from '../../base/tool-manager/glsp-tool-manager';
-import { TYPES } from '../../base/types';
-import { IMouseTool } from '../mouse-tool/mouse-tool';
-import { IFeedbackActionDispatcher, IFeedbackEmitter } from '../tool-feedback/feedback-action-dispatcher';
+import { GLSPKeyTool } from '../../base/view/key-tool';
+import { GLSPMouseTool } from '../../base/view/mouse-tool';
 
 @injectable()
 export abstract class BaseGLSPTool implements GLSPTool {
     @inject(TYPES.IFeedbackActionDispatcher) protected feedbackDispatcher: IFeedbackActionDispatcher;
     @inject(TYPES.IActionDispatcher) protected actionDispatcher: IActionDispatcher;
-    @inject(TYPES.MouseTool) protected mouseTool: IMouseTool;
-    @inject(KeyTool) protected keyTool: KeyTool;
+    @inject(GLSPMouseTool) protected mouseTool: GLSPMouseTool;
+    @inject(GLSPKeyTool) protected keyTool: GLSPKeyTool;
     @inject(EditorContextService) protected readonly editorContext: EditorContextService;
 
+    protected readonly toDisposeOnDisable = new DisposableCollection();
+
     abstract enable(): void;
-    abstract disable(): void;
+
+    disable(): void {
+        this.toDisposeOnDisable.dispose();
+    }
 
     abstract id: string;
 
@@ -43,11 +47,27 @@ export abstract class BaseGLSPTool implements GLSPTool {
         this.actionDispatcher.dispatchAll(actions);
     }
 
-    dispatchFeedback(actions: Action[], feedbackEmitter?: IFeedbackEmitter): void {
-        this.feedbackDispatcher.registerFeedback(feedbackEmitter ?? this, actions);
+    /**
+     * Registers `actions` to be sent out as feedback, i.e., changes that are re-established whenever the `SModelRoot`
+     * has been set or updated.
+     *
+     * @param feedbackActions the actions to be sent out.
+     * @param feedbackEmitter the emitter sending out feedback actions (this tool by default).
+     * @param cleanupActions the actions to be sent out when the feedback is de-registered through the returned Disposable.
+     * @returns A 'Disposable' that de-registers the feedback and cleans up any pending feedback with the given `cleanupActions`.
+     */
+    registerFeedback(feedbackActions: Action[], feedbackEmitter?: IFeedbackEmitter, cleanupActions?: Action[]): Disposable {
+        return this.feedbackDispatcher.registerFeedback(feedbackEmitter ?? this, feedbackActions, cleanupActions);
     }
 
-    deregisterFeedback(actions: Action[], feedbackEmitter?: IFeedbackEmitter): void {
-        this.feedbackDispatcher.deregisterFeedback(feedbackEmitter ?? this, actions);
+    /**
+     * De-registers all feedback from the given `feedbackEmitter` (this tool by default) and cleans up any pending feedback with the
+     * given `cleanupActions`.
+     *
+     * @param feedbackEmitter the emitter to be deregistered (this tool by default).
+     * @param cleanupActions the actions to be dispatched right after the deregistration to clean up any pending feedback.
+     */
+    deregisterFeedback(feedbackEmitter?: IFeedbackEmitter, cleanupActions?: Action[]): void {
+        this.feedbackDispatcher.deregisterFeedback(feedbackEmitter ?? this, cleanupActions);
     }
 }

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

@@ -13,30 +13,33 @@
  *
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
-import { Action, hasStringProp, Point } from '@eclipse-glsp/protocol';
 import { inject, injectable } from 'inversify';
 import { VNode } from 'snabbdom';
 import {
+    Action,
     CommandExecutionContext,
     CommandReturn,
+    Disposable,
     ElementMove,
-    findParentByFeature,
-    isMoveable,
-    isSelectable,
-    isViewport,
     MouseListener,
+    MoveAction,
+    Point,
     SChildElement,
     SModelElement,
     SModelRoot,
-    TYPES
-} from 'sprotty';
-import { MoveAction } from 'sprotty-protocol/lib/actions';
-import { forEachElement } from '../../utils/smodel-util';
-import { addResizeHandles, isResizable, removeResizeHandles, SResizeHandle } from '../change-bounds/model';
-import { createMovementRestrictionFeedback, removeMovementRestrictionFeedback } from '../change-bounds/movement-restrictor';
-import { CursorCSS, cursorFeedbackAction } from '../tool-feedback/css-feedback';
-import { ChangeBoundsTool } from '../tools/change-bounds-tool';
-import { FeedbackCommand } from './model';
+    TYPES,
+    findParentByFeature,
+    hasStringProp,
+    isMoveable,
+    isSelectable,
+    isViewport
+} from '~glsp-sprotty';
+import { CursorCSS, cursorFeedbackAction } from '../../../base/feedback/css-feedback';
+import { FeedbackCommand } from '../../../base/feedback/feedback-command';
+import { forEachElement } from '../../../utils/smodel-util';
+import { SResizeHandle, addResizeHandles, isResizable, removeResizeHandles } from '../../change-bounds/model';
+import { createMovementRestrictionFeedback, removeMovementRestrictionFeedback } from '../../change-bounds/movement-restrictor';
+import { ChangeBoundsTool } from './change-bounds-tool';
 
 export interface ShowChangeBoundsToolResizeFeedbackAction extends Action {
     kind: typeof ShowChangeBoundsToolResizeFeedbackAction.KIND;
@@ -116,9 +119,10 @@ export class HideChangeBoundsToolResizeFeedbackCommand extends FeedbackCommand {
  * the visual feedback but also the basis for sending the change to the server
  * (see also `tools/MoveTool`).
  */
-export class FeedbackMoveMouseListener extends MouseListener {
+export class FeedbackMoveMouseListener extends MouseListener implements Disposable {
     protected hasDragged = false;
-    protected startDragPosition: Point | undefined;
+    protected rootElement?: SModelRoot;
+    protected startDragPosition?: Point;
     protected elementId2startPos = new Map<string, Point>();
 
     constructor(protected tool: ChangeBoundsTool) {
@@ -153,10 +157,12 @@ export class FeedbackMoveMouseListener extends MouseListener {
                 result.push(cursorFeedbackAction(CursorCSS.MOVE));
             }
         }
-        return result;
+        this.tool.registerFeedback(result, this);
+        return [];
     }
 
     protected collectStartPositions(root: SModelRoot): void {
+        this.rootElement = root;
         const selectedElements = root.index.all().filter(element => isSelectable(element) && element.selected);
         const elementsSet = new Set(selectedElements);
         selectedElements
@@ -182,13 +188,29 @@ export class FeedbackMoveMouseListener extends MouseListener {
         if (!this.startDragPosition) {
             return undefined;
         }
-        const elementMoves: ElementMove[] = [];
+
         const viewport = findParentByFeature(target, isViewport);
         const zoom = viewport ? viewport.zoom : 1;
         const delta = {
             x: (event.pageX - this.startDragPosition.x) / zoom,
             y: (event.pageY - this.startDragPosition.y) / zoom
         };
+
+        const elementMoves: ElementMove[] = this.getElementMovesForDelta(target, delta, !event.shiftKey, finished);
+        if (elementMoves.length > 0) {
+            return MoveAction.create(elementMoves, { animate: false, finished });
+        } else {
+            return undefined;
+        }
+    }
+
+    protected getElementMovesForDelta(
+        target: SModelElement,
+        delta: { x: number; y: number },
+        isSnap: boolean,
+        finished: boolean
+    ): ElementMove[] {
+        const elementMoves: ElementMove[] = [];
         this.elementId2startPos.forEach((startPosition, elementId) => {
             const element = target.root.index.getById(elementId);
             if (element) {
@@ -198,7 +220,7 @@ export class FeedbackMoveMouseListener extends MouseListener {
                         y: startPosition.y + delta.y
                     },
                     element,
-                    !event.shiftKey
+                    isSnap
                 );
 
                 if (isMoveable(element)) {
@@ -214,11 +236,7 @@ export class FeedbackMoveMouseListener extends MouseListener {
                 }
             }
         });
-        if (elementMoves.length > 0) {
-            return MoveAction.create(elementMoves, { animate: false, finished });
-        } else {
-            return undefined;
-        }
+        return elementMoves;
     }
 
     protected validateMove(startPosition: Point, toPosition: Point, element: SModelElement, isFinished: boolean): Point {
@@ -235,8 +253,7 @@ export class FeedbackMoveMouseListener extends MouseListener {
             } else {
                 action = removeMovementRestrictionFeedback(element, this.tool.movementRestrictor);
             }
-
-            this.tool.dispatchFeedback([action], this);
+            this.tool.registerFeedback([action], this);
         }
         return newPosition;
     }
@@ -263,18 +280,34 @@ export class FeedbackMoveMouseListener extends MouseListener {
             if (moveAction) {
                 result.push(moveAction);
             }
+            const resetFeedback: Action[] = [];
             if (this.tool.movementRestrictor) {
-                this.tool.deregisterFeedback([removeMovementRestrictionFeedback(target, this.tool.movementRestrictor)], this);
+                resetFeedback.push(removeMovementRestrictionFeedback(target, this.tool.movementRestrictor));
             }
-            result.push(cursorFeedbackAction(CursorCSS.DEFAULT));
+            resetFeedback.push(cursorFeedbackAction(CursorCSS.DEFAULT));
+            this.tool.deregisterFeedback(this, resetFeedback);
+        }
+        this.reset();
+        return result;
+    }
+
+    protected reset(resetFeedback = false): void {
+        if (this.rootElement && resetFeedback) {
+            const elementMoves: ElementMove[] = this.getElementMovesForDelta(this.rootElement, { x: 0, y: 0 }, true, true);
+            const moveAction = MoveAction.create(elementMoves, { animate: false, finished: true });
+            this.tool.deregisterFeedback(this, [moveAction]);
         }
         this.hasDragged = false;
         this.startDragPosition = undefined;
+        this.rootElement = undefined;
         this.elementId2startPos.clear();
-        return result;
     }
 
     override decorate(vnode: VNode, _element: SModelElement): VNode {
         return vnode;
     }
+
+    dispose(): void {
+        this.reset(true);
+    }
 }

package/src/features/tools/{change-bounds-tool.ts → change-bounds/change-bounds-tool.ts}

@@ -13,57 +13,57 @@
  *
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
+import { inject, injectable, optional } from 'inversify';
+
 import {
     Action,
     Bounds,
+    BoundsAware,
     ChangeBoundsOperation,
     ChangeRoutingPointsOperation,
     CompoundOperation,
     Dimension,
+    Disposable,
+    EdgeRouterRegistry,
     ElementAndBounds,
     ElementAndRoutingPoints,
-    Operation,
-    Point,
-    SetBoundsAction
-} from '@eclipse-glsp/protocol';
-import { inject, injectable, optional } from 'inversify';
-import {
-    BoundsAware,
-    EdgeRouterRegistry,
-    findParentByFeature,
     ISnapper,
-    isSelected,
     MouseListener,
+    Operation,
+    Point,
     SChildElement,
     SConnectableElement,
     SModelElement,
     SModelRoot,
-    SParentElement
-} from 'sprotty';
-import { DragAwareMouseListener } from '../../base/drag-aware-mouse-listener';
-import { TYPES } from '../../base/types';
-import { isValidMove, isValidSize } from '../../utils/layout-utils';
+    SParentElement,
+    SetBoundsAction,
+    TYPES,
+    findParentByFeature,
+    isSelected
+} from '~glsp-sprotty';
+import { DragAwareMouseListener } from '../../../base/drag-aware-mouse-listener';
+import { CursorCSS, applyCssClasses, cursorFeedbackAction, deleteCssClasses } from '../../../base/feedback/css-feedback';
+import { ISelectionListener, SelectionService } from '../../../base/selection-service';
+import { PointPositionUpdater } from '../../../features/change-bounds/snap';
+import { isValidMove, isValidSize } from '../../../utils/layout-utils';
 import {
     calcElementAndRoutingPoints,
     forEachElement,
     isNonRoutableSelectedMovableBoundsAware,
     toElementAndBounds
-} from '../../utils/smodel-util';
-import { isBoundsAwareMoveable, isResizable, Resizable, ResizeHandleLocation, SResizeHandle } from '../change-bounds/model';
+} from '../../../utils/smodel-util';
+import { Resizable, ResizeHandleLocation, SResizeHandle, isBoundsAwareMoveable, isResizable } from '../../change-bounds/model';
 import {
-    createMovementRestrictionFeedback,
     IMovementRestrictor,
+    createMovementRestrictionFeedback,
     removeMovementRestrictionFeedback
-} from '../change-bounds/movement-restrictor';
-import { PointPositionUpdater } from '../change-bounds/snap';
-import { SelectionListener, SelectionService } from '../select/selection-service';
+} from '../../change-bounds/movement-restrictor';
+import { BaseGLSPTool } from '../base-glsp-tool';
 import {
     FeedbackMoveMouseListener,
     HideChangeBoundsToolResizeFeedbackAction,
     ShowChangeBoundsToolResizeFeedbackAction
-} from '../tool-feedback/change-bounds-tool-feedback';
-import { applyCssClasses, CursorCSS, cursorFeedbackAction, deleteCssClasses } from '../tool-feedback/css-feedback';
-import { BaseGLSPTool } from './base-glsp-tool';
+} from './change-bounds-tool-feedback';
 
 /**
  * The change bounds tool has the license to move multiple elements or resize a single element by implementing the ChangeBounds operation.
@@ -82,12 +82,10 @@ import { BaseGLSPTool } from './base-glsp-tool';
 export class ChangeBoundsTool extends BaseGLSPTool {
     static ID = 'glsp.change-bounds-tool';
 
-    @inject(TYPES.SelectionService) protected selectionService: SelectionService;
+    @inject(SelectionService) protected selectionService: SelectionService;
     @inject(EdgeRouterRegistry) @optional() readonly edgeRouterRegistry?: EdgeRouterRegistry;
     @inject(TYPES.ISnapper) @optional() readonly snapper?: ISnapper;
     @inject(TYPES.IMovementRestrictor) @optional() readonly movementRestrictor?: IMovementRestrictor;
-    protected feedbackMoveMouseListener: MouseListener;
-    protected changeBoundsListener: MouseListener & SelectionListener;
 
     get id(): string {
         return ChangeBoundsTool.ID;
@@ -95,33 +93,36 @@ export class ChangeBoundsTool extends BaseGLSPTool {
 
     enable(): void {
         // install feedback move mouse listener for client-side move updates
-        this.feedbackMoveMouseListener = this.createMoveMouseListener();
-        this.mouseTool.register(this.feedbackMoveMouseListener);
+        const feedbackMoveMouseListener = this.createMoveMouseListener();
+        if (Disposable.is(feedbackMoveMouseListener)) {
+            this.toDisposeOnDisable.push(feedbackMoveMouseListener);
+        }
 
         // install change bounds listener for client-side resize updates and server-side updates
-        this.changeBoundsListener = this.createChangeBoundsListener();
-        this.mouseTool.register(this.changeBoundsListener);
-        this.selectionService.register(this.changeBoundsListener);
+        const changeBoundsListener = this.createChangeBoundsListener();
+        if (Disposable.is(changeBoundsListener)) {
+            this.toDisposeOnDisable.push(changeBoundsListener);
+        }
+
+        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))
+        );
     }
 
     protected createMoveMouseListener(): MouseListener {
         return new FeedbackMoveMouseListener(this);
     }
 
-    protected createChangeBoundsListener(): MouseListener & SelectionListener {
+    protected createChangeBoundsListener(): MouseListener & ISelectionListener {
         return new ChangeBoundsListener(this);
     }
-
-    disable(): void {
-        this.mouseTool.deregister(this.changeBoundsListener);
-        this.selectionService.deregister(this.changeBoundsListener);
-        this.mouseTool.deregister(this.feedbackMoveMouseListener);
-        this.deregisterFeedback([], this.feedbackMoveMouseListener);
-        this.deregisterFeedback([HideChangeBoundsToolResizeFeedbackAction.create()], this.changeBoundsListener);
-    }
 }
 
-export class ChangeBoundsListener extends DragAwareMouseListener implements SelectionListener {
+export class ChangeBoundsListener extends DragAwareMouseListener implements ISelectionListener, Disposable {
     static readonly CSS_CLASS_ACTIVE = 'active';
 
     // members for calculating the correct position change
@@ -172,12 +173,12 @@ export class ChangeBoundsListener extends DragAwareMouseListener implements Sele
                 const resizeActions = this.handleResizeOnClient(positionUpdate);
                 actions.push(...resizeActions);
             }
-            return actions;
+            this.tool.registerFeedback(actions, this);
         }
         return [];
     }
 
-    override draggingMouseUp(target: SModelElement, event: MouseEvent): Action[] {
+    override draggingMouseUp(target: SModelElement, _event: MouseEvent): Action[] {
         if (this.pointPositionUpdater.isLastDragPositionUndefined()) {
             this.resetPosition();
             return [];
@@ -192,6 +193,7 @@ export class ChangeBoundsListener extends DragAwareMouseListener implements Sele
             actions.push(...this.handleMoveOnServer(target));
         }
         this.resetPosition();
+        this.tool.deregisterFeedback(this, [cursorFeedbackAction(CursorCSS.DEFAULT)]);
         return actions;
     }
 
@@ -291,7 +293,10 @@ export class ChangeBoundsListener extends DragAwareMouseListener implements Sele
             // only allow one element to have the element resize handles
             this.activeResizeElement = moveableElement;
             if (isResizable(this.activeResizeElement)) {
-                this.tool.dispatchFeedback([ShowChangeBoundsToolResizeFeedbackAction.create(this.activeResizeElement.id)], this);
+                this.tool.registerFeedback(
+                    [ShowChangeBoundsToolResizeFeedbackAction.create(this.activeResizeElement.id)],
+                    this.activeResizeElement
+                );
             }
             return true;
         }
@@ -315,12 +320,34 @@ export class ChangeBoundsListener extends DragAwareMouseListener implements Sele
         }
     }
 
-    protected reset(): void {
+    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)) {
-            this.tool.dispatchFeedback([HideChangeBoundsToolResizeFeedbackAction.create()], this);
+            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(
+                    SetBoundsAction.create([
+                        {
+                            elementId: this.activeResizeElement.id,
+                            newPosition: this.initialBounds,
+                            newSize: this.initialBounds
+                        }
+                    ])
+                );
+            }
+            this.tool.deregisterFeedback(this.activeResizeElement, [HideChangeBoundsToolResizeFeedbackAction.create()]);
         }
-        this.tool.dispatchActions([cursorFeedbackAction(CursorCSS.DEFAULT)]);
-        this.resetPosition();
+        resetFeedback.push(cursorFeedbackAction(CursorCSS.DEFAULT));
+        this.tool.deregisterFeedback(this, resetFeedback);
     }
 
     protected resetPosition(): void {

package/src/features/tools/change-bounds/di.config.ts

@@ -0,0 +1,31 @@
+/********************************************************************************
+ * Copyright (c) 2019-2023 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
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the Eclipse
+ * Public License v. 2.0 are satisfied: GNU General Public License, version 2
+ * with the GNU Classpath Exception which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ ********************************************************************************/
+import { ContainerModule } from 'inversify';
+import { TYPES, bindAsService, configureCommand, configureView } from '~glsp-sprotty';
+import { SResizeHandle } from '../../../features/change-bounds/model';
+import { ChangeBoundsTool } from './change-bounds-tool';
+import { HideChangeBoundsToolResizeFeedbackCommand, ShowChangeBoundsToolResizeFeedbackCommand } from './change-bounds-tool-feedback';
+import { SResizeHandleView } from './view';
+
+const changeBoundsToolModule = new ContainerModule((bind, unbind, isBound, rebind) => {
+    const context = { bind, unbind, isBound, rebind };
+    bindAsService(context, TYPES.IDefaultTool, ChangeBoundsTool);
+    configureCommand(context, ShowChangeBoundsToolResizeFeedbackCommand);
+    configureCommand(context, HideChangeBoundsToolResizeFeedbackCommand);
+    configureView(context, SResizeHandle.TYPE, SResizeHandleView);
+});
+
+export default changeBoundsToolModule;

package/src/features/{tool-feedback → tools/change-bounds}/view.tsx

@@ -1,5 +1,5 @@
 /********************************************************************************
- * Copyright (c) 2019-2022 EclipseSource and others.
+ * Copyright (c) 2019-2023 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
@@ -13,27 +13,14 @@
  *
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
-import { Point } from '@eclipse-glsp/protocol';
 import { injectable } from 'inversify';
 import { VNode } from 'snabbdom';
-import { IView, RenderingContext, setAttr, SModelElement, svg } from 'sprotty';
-import { isResizable, ResizeHandleLocation, SResizeHandle } from '../change-bounds/model';
+import { IView, Point, RenderingContext, setAttr, svg } from '~glsp-sprotty';
+import { ResizeHandleLocation, SResizeHandle, isResizable } from '../../change-bounds/model';
 
 // eslint-disable-next-line @typescript-eslint/no-unused-vars
 const JSX = { createElement: svg };
 
-/**
- * This view is used for the invisible end of the feedback edge.
- * A feedback edge is shown as a visual feedback when creating edges.
- */
-@injectable()
-export class FeedbackEdgeEndView implements IView {
-    render(model: Readonly<SModelElement>, context: RenderingContext): VNode {
-        const position: Point = (model as any).position ?? Point.ORIGIN;
-        return <g x={position.x} y={position.y} />;
-    }
-}
-
 @injectable()
 export class SResizeHandleView implements IView {
     render(handle: SResizeHandle, context: RenderingContext): VNode {

package/src/features/tools/{delete-tool.ts → deletion/delete-tool.ts}

@@ -1,5 +1,5 @@
 /********************************************************************************
- * Copyright (c) 2019-2022 EclipseSource and others.
+ * Copyright (c) 2019-2023 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
@@ -13,25 +13,24 @@
  *
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
-import { Action, DeleteElementOperation } from '@eclipse-glsp/protocol';
 import { inject, injectable } from 'inversify';
 import {
+    Action,
+    DeleteElementOperation,
     EnableDefaultToolsAction,
+    KeyListener,
+    KeyTool,
+    MouseListener,
+    SModelElement,
     findParentByFeature,
     isCtrlOrCmd,
     isDeletable,
     isSelectable,
-    KeyListener,
-    KeyTool,
-    MouseListener,
-    SModelElement
-} from 'sprotty';
-import { matchesKeystroke } from 'sprotty/lib/utils/keyboard';
-import { GLSPTool } from '../../base/tool-manager/glsp-tool-manager';
-import { TYPES } from '../../base/types';
-import { IMouseTool } from '../mouse-tool/mouse-tool';
-import { CursorCSS, cursorFeedbackAction } from '../tool-feedback/css-feedback';
-import { IFeedbackActionDispatcher } from '../tool-feedback/feedback-action-dispatcher';
+    matchesKeystroke
+} from '~glsp-sprotty';
+import { CursorCSS, cursorFeedbackAction } from '../../../base/feedback/css-feedback';
+import { GLSPTool } from '../../../base/tool-manager/glsp-tool-manager';
+import { BaseGLSPTool } from '../base-glsp-tool';
 
 /**
  * Deletes selected elements when hitting the `Del` key.
@@ -81,28 +80,20 @@ export class DeleteKeyListener extends KeyListener {
  * Deletes selected elements when clicking on them.
  */
 @injectable()
-export class MouseDeleteTool implements GLSPTool {
+export class MouseDeleteTool extends BaseGLSPTool {
     static ID = 'glsp.delete-mouse';
 
-    isEditTool = true;
-
     protected deleteToolMouseListener: DeleteToolMouseListener = new DeleteToolMouseListener();
 
-    @inject(TYPES.MouseTool) protected mouseTool: IMouseTool;
-    @inject(TYPES.IFeedbackActionDispatcher) protected readonly feedbackDispatcher: IFeedbackActionDispatcher;
-
     get id(): string {
         return MouseDeleteTool.ID;
     }
 
     enable(): void {
-        this.mouseTool.register(this.deleteToolMouseListener);
-        this.feedbackDispatcher.registerFeedback(this, [cursorFeedbackAction(CursorCSS.ELEMENT_DELETION)]);
-    }
-
-    disable(): void {
-        this.mouseTool.deregister(this.deleteToolMouseListener);
-        this.feedbackDispatcher.registerFeedback(this, [cursorFeedbackAction()]);
+        this.toDisposeOnDisable.push(
+            this.mouseTool.registerListener(this.deleteToolMouseListener),
+            this.registerFeedback([cursorFeedbackAction(CursorCSS.ELEMENT_DELETION)], this, [cursorFeedbackAction()])
+        );
     }
 }