@eclipse-glsp/client 1.1.0-next.35bf56e.230 → 1.1.0-next.383e4e9.264

package/src/features/tools/{edge-creation-tool.ts → edge-creation/edge-creation-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,67 +13,52 @@
  *
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
-import { Action, CreateEdgeOperation, TriggerEdgeCreationAction } from '@eclipse-glsp/protocol';
 import { inject, injectable } from 'inversify';
 import {
+    Action,
     AnchorComputerRegistry,
+    CreateEdgeOperation,
     EnableDefaultToolsAction,
-    EnableToolsAction,
+    SEdge,
+    SModelElement,
+    TriggerEdgeCreationAction,
     findParentByFeature,
-    IActionHandler,
     isConnectable,
-    isCtrlOrCmd,
-    SEdge,
-    SModelElement
-} from 'sprotty';
-import { DragAwareMouseListener } from '../../base/drag-aware-mouse-listener';
-import {
-    DrawFeedbackEdgeAction,
-    FeedbackEdgeEndMovingMouseListener,
-    RemoveFeedbackEdgeAction
-} from '../tool-feedback/creation-tool-feedback';
-import { CursorCSS, cursorFeedbackAction } from '../tool-feedback/css-feedback';
-import { BaseGLSPTool } from './base-glsp-tool';
+    isCtrlOrCmd
+} from '~glsp-sprotty';
+import { DragAwareMouseListener } from '../../../base/drag-aware-mouse-listener';
+
+import { CursorCSS, cursorFeedbackAction } from '../../../base/feedback/css-feedback';
+import { BaseGLSPCreationTool } from '../base-glsp-creation-tool';
+import { DrawFeedbackEdgeAction, RemoveFeedbackEdgeAction } from './dangling-edge-feedback';
+import { FeedbackEdgeEndMovingMouseListener } from './edge-creation-tool-feedback';
 
 /**
  * Tool to create connections in a Diagram, by selecting a source and target node.
  */
 @injectable()
-export class EdgeCreationTool extends BaseGLSPTool implements IActionHandler {
+export class EdgeCreationTool extends BaseGLSPCreationTool<TriggerEdgeCreationAction> {
     static ID = 'tool_create_edge';
 
     @inject(AnchorComputerRegistry) protected anchorRegistry: AnchorComputerRegistry;
 
-    protected triggerAction: TriggerEdgeCreationAction;
-    protected creationToolMouseListener: EdgeCreationToolMouseListener;
-    protected feedbackEndMovingMouseListener: FeedbackEdgeEndMovingMouseListener;
+    protected isTriggerAction = TriggerEdgeCreationAction.is;
 
     get id(): string {
         return EdgeCreationTool.ID;
     }
 
-    enable(): void {
-        if (this.triggerAction === undefined) {
-            throw new TypeError(`Could not enable tool ${this.id}.The triggerAction cannot be undefined.`);
-        }
-        this.creationToolMouseListener = new EdgeCreationToolMouseListener(this.triggerAction, this);
-        this.mouseTool.register(this.creationToolMouseListener);
-        this.feedbackEndMovingMouseListener = new FeedbackEdgeEndMovingMouseListener(this.anchorRegistry);
-        this.mouseTool.register(this.feedbackEndMovingMouseListener);
-        this.dispatchFeedback([cursorFeedbackAction(CursorCSS.OPERATION_NOT_ALLOWED)]);
-    }
-
-    disable(): void {
-        this.mouseTool.deregister(this.creationToolMouseListener);
-        this.mouseTool.deregister(this.feedbackEndMovingMouseListener);
-        this.deregisterFeedback([RemoveFeedbackEdgeAction.create(), cursorFeedbackAction()]);
-    }
-
-    handle(action: Action): Action | void {
-        if (TriggerEdgeCreationAction.is(action)) {
-            this.triggerAction = action;
-            return EnableToolsAction.create([this.id]);
-        }
+    doEnable(): void {
+        const mouseMovingFeedback = new FeedbackEdgeEndMovingMouseListener(this.anchorRegistry, this.feedbackDispatcher);
+        this.toDisposeOnDisable.push(
+            mouseMovingFeedback,
+            this.mouseTool.registerListener(new EdgeCreationToolMouseListener(this.triggerAction, this)),
+            this.mouseTool.registerListener(mouseMovingFeedback),
+            this.registerFeedback([cursorFeedbackAction(CursorCSS.OPERATION_NOT_ALLOWED)], this, [
+                RemoveFeedbackEdgeAction.create(),
+                cursorFeedbackAction()
+            ])
+        );
     }
 }
 
@@ -96,7 +81,7 @@ export class EdgeCreationToolMouseListener extends DragAwareMouseListener {
         this.target = undefined;
         this.currentTarget = undefined;
         this.allowedTarget = false;
-        this.tool.dispatchFeedback([RemoveFeedbackEdgeAction.create()]);
+        this.tool.registerFeedback([RemoveFeedbackEdgeAction.create()]);
     }
 
     override nonDraggingMouseUp(_element: SModelElement, event: MouseEvent): Action[] {
@@ -105,7 +90,7 @@ export class EdgeCreationToolMouseListener extends DragAwareMouseListener {
             if (!this.isSourceSelected()) {
                 if (this.currentTarget && this.allowedTarget) {
                     this.source = this.currentTarget.id;
-                    this.tool.dispatchFeedback([
+                    this.tool.registerFeedback([
                         DrawFeedbackEdgeAction.create({ elementTypeId: this.triggerAction.elementTypeId, sourceId: this.source })
                     ]);
                 }
@@ -115,6 +100,11 @@ export class EdgeCreationToolMouseListener extends DragAwareMouseListener {
                 }
             }
             if (this.source && this.target) {
+                if (!isCtrlOrCmd(event)) {
+                    result.push(EnableDefaultToolsAction.create());
+                } else {
+                    this.reinitialize();
+                }
                 result.push(
                     CreateEdgeOperation.create({
                         elementTypeId: this.triggerAction.elementTypeId,
@@ -123,11 +113,6 @@ export class EdgeCreationToolMouseListener extends DragAwareMouseListener {
                         args: this.triggerAction.args
                     })
                 );
-                if (!isCtrlOrCmd(event)) {
-                    result.push(EnableDefaultToolsAction.create());
-                } else {
-                    this.reinitialize();
-                }
             }
         } else if (event.button === 2) {
             result.push(EnableDefaultToolsAction.create());

package/{lib/features/tool-feedback/view.d.ts → src/features/tools/edge-creation/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,20 +13,21 @@
  *
  * 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, SModelElement } from 'sprotty';
-import { SResizeHandle } from '../change-bounds/model';
+import { IView, Point, RenderingContext, SModelElement, svg } from '~glsp-sprotty';
+
+// 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.
  */
-export declare class FeedbackEdgeEndView implements IView {
-    render(model: Readonly<SModelElement>, context: RenderingContext): VNode;
+@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} />;
+    }
 }
-export declare class SResizeHandleView implements IView {
-    render(handle: SResizeHandle, context: RenderingContext): VNode;
-    protected getPosition(handle: SResizeHandle): Point | undefined;
-    getRadius(): number;
-}
-//# sourceMappingURL=view.d.ts.map

package/src/features/tools/edge-edit/edge-edit-module.ts

@@ -0,0 +1,38 @@
+/********************************************************************************
+ * 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 { FeatureModule, TYPES, bindAsService, configureCommand } from '~glsp-sprotty';
+import { configureDanglingFeedbackEdge } from '../edge-creation/dangling-edge-feedback';
+import { EdgeEditTool } from './edge-edit-tool';
+import {
+    DrawFeedbackEdgeSourceCommand,
+    HideEdgeReconnectHandlesFeedbackCommand,
+    ShowEdgeReconnectHandlesFeedbackCommand,
+    SwitchRoutingModeCommand
+} from './edge-edit-tool-feedback';
+
+export const edgeEditToolModule = new FeatureModule((bind, unbind, isBound, rebind) => {
+    const context = { bind, unbind, isBound, rebind };
+    bindAsService(context, TYPES.IDefaultTool, EdgeEditTool);
+
+    // reconnect edge tool feedback
+    configureCommand(context, ShowEdgeReconnectHandlesFeedbackCommand);
+    configureCommand(context, HideEdgeReconnectHandlesFeedbackCommand);
+    configureCommand(context, DrawFeedbackEdgeSourceCommand);
+    configureCommand(context, SwitchRoutingModeCommand);
+
+    // dangling edge feedback
+    configureDanglingFeedbackEdge(context);
+});

package/src/features/{tool-feedback → tools/edge-edit}/edge-edit-tool-feedback.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,37 +13,43 @@
  *
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
-import { Action, Bounds, hasStringProp, Point } from '@eclipse-glsp/protocol';
 import { inject, injectable } from 'inversify';
 import { VNode } from 'snabbdom';
 import {
+    Action,
     AnchorComputerRegistry,
+    Bounds,
     CommandExecutionContext,
     CommandReturn,
+    Disposable,
     EdgeRouterRegistry,
     ElementMove,
-    findChildrenAtPosition,
-    findParentByFeature,
-    isBoundsAware,
-    isConnectable,
     ISnapper,
-    isSelected,
     MouseListener,
+    MoveAction,
+    Point,
     PolylineEdgeRouter,
     SConnectableElement,
     SModelElement,
     SRoutingHandle,
     SwitchEditModeAction,
     SwitchEditModeCommand,
-    TYPES
-} from 'sprotty';
-import { MoveAction } from 'sprotty-protocol/lib/actions';
-import { forEachElement, isRoutable, isRoutingHandle } from '../../utils/smodel-util';
-import { getAbsolutePosition, toAbsoluteBounds } from '../../utils/viewpoint-util';
-import { PointPositionUpdater } from '../change-bounds/snap';
-import { addReconnectHandles, removeReconnectHandles } from '../reconnect/model';
-import { FeedbackEdgeEnd, feedbackEdgeEndId, FeedbackEdgeEndMovingMouseListener, feedbackEdgeId } from './creation-tool-feedback';
-import { FeedbackCommand } from './model';
+    TYPES,
+    findChildrenAtPosition,
+    findParentByFeature,
+    hasStringProp,
+    isBoundsAware,
+    isConnectable,
+    isSelected
+} from '~glsp-sprotty';
+import { IFeedbackActionDispatcher } from '../../../base/feedback/feedback-action-dispatcher';
+import { FeedbackCommand } from '../../../base/feedback/feedback-command';
+import { forEachElement, isRoutable, isRoutingHandle } from '../../../utils/smodel-util';
+import { getAbsolutePosition, toAbsoluteBounds } from '../../../utils/viewpoint-util';
+import { PointPositionUpdater } from '../../change-bounds/snap';
+import { addReconnectHandles, removeReconnectHandles } from '../../reconnect/model';
+import { FeedbackEdgeEnd, feedbackEdgeEndId, feedbackEdgeId } from '../edge-creation/dangling-edge-feedback';
+import { FeedbackEdgeEndMovingMouseListener } from '../edge-creation/edge-creation-tool-feedback';
 
 /**
  * RECONNECT HANDLES FEEDBACK
@@ -64,6 +70,7 @@ export namespace ShowEdgeReconnectHandlesFeedbackAction {
         return { kind: KIND, elementId };
     }
 }
+
 export interface HideEdgeReconnectHandlesFeedbackAction extends Action {
     kind: typeof HideEdgeReconnectHandlesFeedbackAction.KIND;
 }
@@ -132,6 +139,7 @@ export namespace SwitchRoutingModeAction {
         };
     }
 }
+
 @injectable()
 export class SwitchRoutingModeCommand extends SwitchEditModeCommand {
     static override KIND = SwitchRoutingModeAction.KIND;
@@ -184,13 +192,13 @@ export class DrawFeedbackEdgeSourceCommand extends FeedbackCommand {
  */
 
 export class FeedbackEdgeTargetMovingMouseListener extends FeedbackEdgeEndMovingMouseListener {
-    constructor(protected override anchorRegistry: AnchorComputerRegistry) {
-        super(anchorRegistry);
+    constructor(anchorRegistry: AnchorComputerRegistry, feedbackDispatcher: IFeedbackActionDispatcher) {
+        super(anchorRegistry, feedbackDispatcher);
     }
 }
 
-export class FeedbackEdgeSourceMovingMouseListener extends MouseListener {
-    constructor(protected anchorRegistry: AnchorComputerRegistry) {
+export class FeedbackEdgeSourceMovingMouseListener extends MouseListener implements Disposable {
+    constructor(protected anchorRegistry: AnchorComputerRegistry, protected feedbackDispatcher: IFeedbackActionDispatcher) {
         super();
     }
 
@@ -204,16 +212,20 @@ export class FeedbackEdgeSourceMovingMouseListener extends MouseListener {
         const edge = edgeEnd.feedbackEdge;
         const position = getAbsolutePosition(edgeEnd, event);
         const endAtMousePosition = findChildrenAtPosition(target.root, position).find(
-            e => isConnectable(e) && e.canConnect(edge, 'source')
+            element => isConnectable(element) && element.canConnect(edge, 'source')
         );
 
         if (endAtMousePosition instanceof SConnectableElement && edge.target && isBoundsAware(edge.target)) {
             const anchor = this.computeAbsoluteAnchor(endAtMousePosition, Bounds.center(edge.target.bounds));
             if (Point.euclideanDistance(anchor, edgeEnd.position) > 1) {
-                return [MoveAction.create([{ elementId: edgeEnd.id, toPosition: anchor }], { animate: false })];
+                this.feedbackDispatcher.registerFeedback(this, [
+                    MoveAction.create([{ elementId: edgeEnd.id, toPosition: anchor }], { animate: false })
+                ]);
             }
         } else {
-            return [MoveAction.create([{ elementId: edgeEnd.id, toPosition: position }], { animate: false })];
+            this.feedbackDispatcher.registerFeedback(this, [
+                MoveAction.create([{ elementId: edgeEnd.id, toPosition: position }], { animate: false })
+            ]);
         }
 
         return [];
@@ -233,6 +245,10 @@ export class FeedbackEdgeSourceMovingMouseListener extends MouseListener {
         }
         return anchor;
     }
+
+    dispose(): void {
+        this.feedbackDispatcher.deregisterFeedback(this);
+    }
 }
 
 export class FeedbackEdgeRouteMovingMouseListener extends MouseListener {
@@ -338,8 +354,7 @@ export class FeedbackEdgeRouteMovingMouseListener extends MouseListener {
 /**
  * UTILITY FUNCTIONS
  */
-
-function drawFeedbackEdgeSource(context: CommandExecutionContext, targetId: string, elementTypeId: string): void {
+export function drawFeedbackEdgeSource(context: CommandExecutionContext, targetId: string, elementTypeId: string): void {
     const root = context.root;
     const targetChild = root.index.getById(targetId);
     if (!targetChild) {

package/src/features/tools/{edge-edit-tool.ts → edge-edit/edge-edit-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,29 +13,33 @@
  *
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
-import { Action, ChangeRoutingPointsOperation, ReconnectEdgeOperation } from '@eclipse-glsp/protocol';
 import { inject, injectable, optional } from 'inversify';
 import {
+    Action,
     AnchorComputerRegistry,
-    canEditRouting,
+    ChangeRoutingPointsOperation,
     Connectable,
+    Disposable,
     EdgeRouterRegistry,
-    findParentByFeature,
-    isConnectable,
     ISnapper,
-    isSelected,
+    ReconnectEdgeOperation,
     SModelElement,
     SModelRoot,
     SRoutableElement,
-    SRoutingHandle
-} from 'sprotty';
-import { DragAwareMouseListener } from '../../base/drag-aware-mouse-listener';
-import { TYPES } from '../../base/types';
-import { calcElementAndRoutingPoints, isRoutable, isRoutingHandle } from '../../utils/smodel-util';
-import { isReconnectable, isReconnectHandle, isSourceRoutingHandle, isTargetRoutingHandle, SReconnectHandle } from '../reconnect/model';
-import { SelectionListener, SelectionService } from '../select/selection-service';
-import { DrawFeedbackEdgeAction, feedbackEdgeId, RemoveFeedbackEdgeAction } from '../tool-feedback/creation-tool-feedback';
-import { CursorCSS, cursorFeedbackAction } from '../tool-feedback/css-feedback';
+    SRoutingHandle,
+    TYPES,
+    canEditRouting,
+    findParentByFeature,
+    isConnectable,
+    isSelected
+} from '~glsp-sprotty';
+import { DragAwareMouseListener } from '../../../base/drag-aware-mouse-listener';
+import { CursorCSS, cursorFeedbackAction } from '../../../base/feedback/css-feedback';
+import { ISelectionListener, SelectionService } from '../../../base/selection-service';
+import { calcElementAndRoutingPoints, isRoutable, isRoutingHandle } from '../../../utils/smodel-util';
+import { SReconnectHandle, isReconnectHandle, isReconnectable, isSourceRoutingHandle, isTargetRoutingHandle } from '../../reconnect/model';
+import { BaseGLSPTool } from '../base-glsp-tool';
+import { DrawFeedbackEdgeAction, RemoveFeedbackEdgeAction, feedbackEdgeId } from '../edge-creation/dangling-edge-feedback';
 import {
     DrawFeedbackEdgeSourceAction,
     FeedbackEdgeRouteMovingMouseListener,
@@ -44,14 +48,13 @@ import {
     HideEdgeReconnectHandlesFeedbackAction,
     ShowEdgeReconnectHandlesFeedbackAction,
     SwitchRoutingModeAction
-} from '../tool-feedback/edge-edit-tool-feedback';
-import { BaseGLSPTool } from './base-glsp-tool';
+} from './edge-edit-tool-feedback';
 
 @injectable()
 export class EdgeEditTool extends BaseGLSPTool {
     static ID = 'glsp.edge-edit-tool';
 
-    @inject(TYPES.SelectionService) protected selectionService: SelectionService;
+    @inject(SelectionService) protected selectionService: SelectionService;
     @inject(AnchorComputerRegistry) protected anchorRegistry: AnchorComputerRegistry;
     @inject(EdgeRouterRegistry) @optional() readonly edgeRouterRegistry?: EdgeRouterRegistry;
     @inject(TYPES.ISnapper) @optional() readonly snapper?: ISnapper;
@@ -67,13 +70,19 @@ export class EdgeEditTool extends BaseGLSPTool {
 
     enable(): void {
         this.edgeEditListener = new EdgeEditListener(this);
-        this.mouseTool.register(this.edgeEditListener);
-        this.selectionService.register(this.edgeEditListener);
 
         // install feedback move mouse listener for client-side move updates
-        this.feedbackEdgeSourceMovingListener = new FeedbackEdgeSourceMovingMouseListener(this.anchorRegistry);
-        this.feedbackEdgeTargetMovingListener = new FeedbackEdgeTargetMovingMouseListener(this.anchorRegistry);
+        this.feedbackEdgeSourceMovingListener = new FeedbackEdgeSourceMovingMouseListener(this.anchorRegistry, this.feedbackDispatcher);
+        this.feedbackEdgeTargetMovingListener = new FeedbackEdgeTargetMovingMouseListener(this.anchorRegistry, this.feedbackDispatcher);
         this.feedbackMovingListener = new FeedbackEdgeRouteMovingMouseListener(this.edgeRouterRegistry, this.snapper);
+
+        this.toDisposeOnDisable.push(
+            Disposable.create(() => this.edgeEditListener.reset()),
+            this.mouseTool.registerListener(this.edgeEditListener),
+            this.feedbackEdgeSourceMovingListener,
+            this.feedbackEdgeTargetMovingListener,
+            this.selectionService.onSelectionChanged(change => this.edgeEditListener.selectionChanged(change.root, change.selectedElements))
+        );
     }
 
     registerFeedbackListeners(): void {
@@ -83,20 +92,15 @@ export class EdgeEditTool extends BaseGLSPTool {
     }
 
     deregisterFeedbackListeners(): void {
+        this.feedbackEdgeSourceMovingListener.dispose();
+        this.feedbackEdgeTargetMovingListener.dispose();
         this.mouseTool.deregister(this.feedbackEdgeSourceMovingListener);
         this.mouseTool.deregister(this.feedbackEdgeTargetMovingListener);
         this.mouseTool.deregister(this.feedbackMovingListener);
     }
-
-    disable(): void {
-        this.edgeEditListener.reset();
-        this.selectionService.deregister(this.edgeEditListener);
-        this.deregisterFeedbackListeners();
-        this.mouseTool.deregister(this.edgeEditListener);
-    }
 }
 
-class EdgeEditListener extends DragAwareMouseListener implements SelectionListener {
+export class EdgeEditListener extends DragAwareMouseListener implements ISelectionListener {
     // active selection data
     protected edge?: SRoutableElement;
     protected routingHandle?: SRoutingHandle;
@@ -130,7 +134,7 @@ class EdgeEditListener extends DragAwareMouseListener implements SelectionListen
         if (isReconnectable(edge)) {
             feedbackActions.push(ShowEdgeReconnectHandlesFeedbackAction.create(this.edge.id));
         }
-        this.tool.dispatchFeedback(feedbackActions);
+        this.tool.registerFeedback(feedbackActions);
     }
 
     protected isEdgeSelected(): boolean {
@@ -140,14 +144,14 @@ class EdgeEditListener extends DragAwareMouseListener implements SelectionListen
     protected setReconnectHandleSelected(edge: SRoutableElement, reconnectHandle: SReconnectHandle): void {
         if (this.edge && this.edge.target && this.edge.source) {
             if (isSourceRoutingHandle(edge, reconnectHandle)) {
-                this.tool.dispatchFeedback([
+                this.tool.registerFeedback([
                     HideEdgeReconnectHandlesFeedbackAction.create(),
                     cursorFeedbackAction(CursorCSS.EDGE_RECONNECT),
                     DrawFeedbackEdgeSourceAction.create({ elementTypeId: this.edge.type, targetId: this.edge.targetId })
                 ]);
                 this.reconnectMode = 'NEW_SOURCE';
             } else if (isTargetRoutingHandle(edge, reconnectHandle)) {
-                this.tool.dispatchFeedback([
+                this.tool.registerFeedback([
                     HideEdgeReconnectHandlesFeedbackAction.create(),
                     cursorFeedbackAction(CursorCSS.EDGE_CREATION_TARGET),
                     DrawFeedbackEdgeAction.create({ elementTypeId: this.edge.type, sourceId: this.edge.sourceId })
@@ -255,11 +259,11 @@ class EdgeEditListener extends DragAwareMouseListener implements SelectionListen
                         (this.reconnectMode === 'NEW_SOURCE' && currentTarget.canConnect(this.edge, 'source')) ||
                         (this.reconnectMode === 'NEW_TARGET' && currentTarget.canConnect(this.edge, 'target'))
                     ) {
-                        this.tool.dispatchFeedback([cursorFeedbackAction(CursorCSS.EDGE_RECONNECT)]);
+                        this.tool.registerFeedback([cursorFeedbackAction(CursorCSS.EDGE_RECONNECT)]);
                         return [];
                     }
                 }
-                this.tool.dispatchFeedback([cursorFeedbackAction(CursorCSS.OPERATION_NOT_ALLOWED)]);
+                this.tool.registerFeedback([cursorFeedbackAction(CursorCSS.OPERATION_NOT_ALLOWED)]);
             }
         }
         return [];
@@ -312,7 +316,7 @@ class EdgeEditListener extends DragAwareMouseListener implements SelectionListen
             result.push(SwitchRoutingModeAction.create({ elementsToDeactivate: [this.edge.id] }));
         }
         result.push(...[HideEdgeReconnectHandlesFeedbackAction.create(), cursorFeedbackAction(), RemoveFeedbackEdgeAction.create()]);
-        this.tool.deregisterFeedback(result);
+        this.tool.deregisterFeedback(undefined, result);
         this.tool.deregisterFeedbackListeners();
     }
 }

package/src/features/tools/{marquee-behavior.ts → marquee-selection/marquee-behavior.ts}

@@ -1,5 +1,5 @@
 /********************************************************************************
- * Copyright (c) 2021-2022 EclipseSource and others.
+ * Copyright (c) 2021-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
@@ -14,9 +14,8 @@
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
 
-import { Bounds, Point } from '@eclipse-glsp/protocol';
-import { PointToPointLine } from 'sprotty';
-import { DrawMarqueeAction } from '../tool-feedback/marquee-tool-feedback';
+import { Bounds, Point, PointToPointLine } from '~glsp-sprotty';
+import { DrawMarqueeAction } from './marquee-tool-feedback';
 
 export interface IMarqueeBehavior {
     readonly entireElement: boolean;
@@ -78,7 +77,7 @@ export class MarqueeUtil {
         return horizontallyIn && verticallyIn;
     }
 
-    private isEntireEdgeMarked(points: Point[]): boolean {
+    protected isEntireEdgeMarked(points: Point[]): boolean {
         for (let i = 0; i < points.length; i++) {
             if (!this.pointInRect(points[i])) {
                 return false;
@@ -87,7 +86,7 @@ export class MarqueeUtil {
         return true;
     }
 
-    private isPartOfEdgeMarked(points: Point[]): boolean {
+    protected isPartOfEdgeMarked(points: Point[]): boolean {
         for (let i = 0; i < points.length - 1; i++) {
             if (this.isLineMarked(points[i], points[i + 1])) {
                 return true;
@@ -96,7 +95,7 @@ export class MarqueeUtil {
         return false;
     }
 
-    private isLineMarked(point1: Point, point2: Point): boolean {
+    protected isLineMarked(point1: Point, point2: Point): boolean {
         const line = new PointToPointLine(point1, point2);
         return (
             this.pointInRect(point1) ||
@@ -108,11 +107,11 @@ export class MarqueeUtil {
         );
     }
 
-    private lineIntersect(line: PointToPointLine, p1: Point, p2: Point): boolean {
+    protected lineIntersect(line: PointToPointLine, p1: Point, p2: Point): boolean {
         return line.intersection(new PointToPointLine(p1, p2)) !== undefined;
     }
 
-    private pointInRect(point: Point): boolean {
+    protected pointInRect(point: Point): boolean {
         const boolX =
             this.startPoint.x <= this.currentPoint.x
                 ? this.isBetween(point.x, this.startPoint.x, this.currentPoint.x)
@@ -124,7 +123,7 @@ export class MarqueeUtil {
         return boolX && boolY;
     }
 
-    private isElementBetweenXAxis(elementBounds: Bounds, marqueeLeft: number, marqueeRight: number): boolean {
+    protected isElementBetweenXAxis(elementBounds: Bounds, marqueeLeft: number, marqueeRight: number): boolean {
         const leftEdge = this.isBetween(elementBounds.x, marqueeLeft, marqueeRight);
         const rightEdge = this.isBetween(elementBounds.x + elementBounds.width, marqueeLeft, marqueeRight);
         if (this.marqueeBehavior.entireElement) {
@@ -138,7 +137,7 @@ export class MarqueeUtil {
         );
     }
 
-    private isElementBetweenYAxis(elementBounds: Bounds, marqueeTop: number, marqueeBottom: number): boolean {
+    protected isElementBetweenYAxis(elementBounds: Bounds, marqueeTop: number, marqueeBottom: number): boolean {
         const topEdge = this.isBetween(elementBounds.y, marqueeTop, marqueeBottom);
         const bottomEdge = this.isBetween(elementBounds.y + elementBounds.height, marqueeTop, marqueeBottom);
         if (this.marqueeBehavior.entireElement) {
@@ -152,7 +151,7 @@ export class MarqueeUtil {
         );
     }
 
-    private isBetween(x: number, lower: number, upper: number): boolean {
+    protected isBetween(x: number, lower: number, upper: number): boolean {
         return lower <= x && x <= upper;
     }
 }