@eclipse-glsp/client 1.1.0-RC09 → 1.1.0-next.0363f0b.261

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

package/src/features/tools/{marquee-mouse-tool.ts → marquee-selection/marquee-mouse-tool.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
@@ -13,27 +13,28 @@
  *
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
-import { Action, SelectAction } from '@eclipse-glsp/protocol';
 import { inject, injectable, optional } from 'inversify';
 import {
+    Action,
     BoundsAware,
+    DOMHelper,
     EnableDefaultToolsAction,
-    isSelectable,
-    isSelected,
     KeyListener,
     SEdge,
     SModelElement,
     SModelRoot,
-    SNode
-} from 'sprotty';
-import { DOMHelper } from 'sprotty/lib/base/views/dom-helper';
-import { DragAwareMouseListener } from '../../base/drag-aware-mouse-listener';
-import { TYPES } from '../../base/types';
-import { getAbsolutePosition, toAbsoluteBounds } from '../../utils/viewpoint-util';
-import { CursorCSS, cursorFeedbackAction } from '../tool-feedback/css-feedback';
-import { RemoveMarqueeAction } from '../tool-feedback/marquee-tool-feedback';
-import { BaseGLSPTool } from './base-glsp-tool';
+    SNode,
+    SelectAction,
+    TYPES,
+    isSelectable,
+    isSelected
+} from '~glsp-sprotty';
+import { DragAwareMouseListener } from '../../../base/drag-aware-mouse-listener';
+import { CursorCSS, cursorFeedbackAction } from '../../../base/feedback/css-feedback';
+import { getAbsolutePosition, toAbsoluteBounds } from '../../../utils/viewpoint-util';
+import { BaseGLSPTool } from '../base-glsp-tool';
 import { IMarqueeBehavior, MarqueeUtil } from './marquee-behavior';
+import { RemoveMarqueeAction } from './marquee-tool-feedback';
 
 @injectable()
 export class MarqueeMouseTool extends BaseGLSPTool {
@@ -42,7 +43,6 @@ export class MarqueeMouseTool extends BaseGLSPTool {
     @inject(TYPES.DOMHelper) protected domHelper: DOMHelper;
     @inject(TYPES.IMarqueeBehavior) @optional() protected marqueeBehavior: IMarqueeBehavior;
 
-    protected marqueeMouseListener: MarqueeMouseListener;
     protected shiftKeyListener: ShiftKeyListener = new ShiftKeyListener();
 
     get id(): string {
@@ -50,16 +50,11 @@ export class MarqueeMouseTool extends BaseGLSPTool {
     }
 
     enable(): void {
-        this.marqueeMouseListener = new MarqueeMouseListener(this.domHelper, this.editorContext.modelRoot, this.marqueeBehavior);
-        this.mouseTool.register(this.marqueeMouseListener);
-        this.keyTool.register(this.shiftKeyListener);
-        this.dispatchFeedback([cursorFeedbackAction(CursorCSS.MARQUEE)]);
-    }
-
-    disable(): void {
-        this.mouseTool.deregister(this.marqueeMouseListener);
-        this.keyTool.deregister(this.shiftKeyListener);
-        this.deregisterFeedback([cursorFeedbackAction()]);
+        this.toDisposeOnDisable.push(
+            this.mouseTool.registerListener(new MarqueeMouseListener(this.domHelper, this.editorContext.modelRoot, this.marqueeBehavior)),
+            this.keyTool.registerListener(this.shiftKeyListener),
+            this.registerFeedback([cursorFeedbackAction(CursorCSS.MARQUEE)], this, [cursorFeedbackAction()])
+        );
     }
 }
 
@@ -113,16 +108,12 @@ export class MarqueeMouseListener extends DragAwareMouseListener {
             const nodeIdsSelected = this.nodes.filter(e => this.marqueeUtil.isNodeMarked(toAbsoluteBounds(e))).map(e => e.id);
             const edgeIdsSelected = this.edges.filter(e => this.isEdgeMarked(e)).map(e => this.domHelper.findSModelIdByDOMElement(e));
             const selected = nodeIdsSelected.concat(edgeIdsSelected);
-            return [
-                SelectAction.create({ deselectedElementsIDs: Array.from(target.root.index.all().map(e => e.id)) }),
-                SelectAction.create({ selectedElementsIDs: selected.concat(this.previouslySelected) }),
-                this.marqueeUtil.drawMarqueeAction()
-            ];
+            return [SelectAction.setSelection(selected.concat(this.previouslySelected)), this.marqueeUtil.drawMarqueeAction()];
         }
         return [];
     }
 
-    override mouseUp(target: SModelElement, event: MouseEvent): Action[] {
+    override mouseUp(_target: SModelElement, event: MouseEvent): Action[] {
         this.isActive = false;
         if (event.shiftKey) {
             return [RemoveMarqueeAction.create()];

package/src/features/tools/marquee-selection/marquee-selection-module.ts

@@ -0,0 +1,32 @@
+/********************************************************************************
+ * 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, configureModelElement } from '~glsp-sprotty';
+import { MarqueeMouseTool } from './marquee-mouse-tool';
+import { MarqueeTool } from './marquee-tool';
+import { DrawMarqueeCommand, MARQUEE, RemoveMarqueeCommand } from './marquee-tool-feedback';
+import { MarqueeNode } from './model';
+import { MarqueeView } from './view';
+
+export const marqueeSelectionToolModule = new FeatureModule((bind, unbind, isBound, rebind) => {
+    const context = { bind, unbind, isBound, rebind };
+    bindAsService(context, TYPES.IDefaultTool, MarqueeTool);
+    bindAsService(context, TYPES.ITool, MarqueeMouseTool);
+
+    configureCommand(context, DrawMarqueeCommand);
+    configureCommand(context, RemoveMarqueeCommand);
+
+    configureModelElement(context, MARQUEE, MarqueeNode, MarqueeView);
+});

package/src/features/{tool-feedback → tools/marquee-selection}/marquee-tool-feedback.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
@@ -13,19 +13,21 @@
  *
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
-import { Action, hasObjectProp, Point } from '@eclipse-glsp/protocol';
 import { inject, injectable } from 'inversify';
 import {
+    Action,
     AnchorComputerRegistry,
     CommandExecutionContext,
     CommandReturn,
     MouseListener,
+    Point,
     SChildElement,
     SModelElement,
     SModelRoot,
-    TYPES
-} from 'sprotty';
-import { FeedbackCommand } from './model';
+    TYPES,
+    hasObjectProp
+} from '~glsp-sprotty';
+import { FeedbackCommand } from '../../../base/feedback/feedback-command';
 
 export interface DrawMarqueeAction extends Action {
     kind: typeof DrawMarqueeAction.KIND;

package/src/features/tools/{marquee-tool.ts → marquee-selection/marquee-tool.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
@@ -13,10 +13,9 @@
  *
  * 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 { EnableToolsAction, KeyListener, KeyTool, SModelElement } from 'sprotty';
-import { BaseGLSPTool } from '../tools/base-glsp-tool';
+import { injectable } from 'inversify';
+import { Action, EnableToolsAction, KeyListener, SModelElement } from '~glsp-sprotty';
+import { BaseGLSPTool } from '../base-glsp-tool';
 import { MarqueeMouseTool } from './marquee-mouse-tool';
 
 @injectable()
@@ -25,24 +24,18 @@ export class MarqueeTool extends BaseGLSPTool {
 
     protected marqueeKeyListener: MarqueeKeyListener = new MarqueeKeyListener();
 
-    @inject(KeyTool) protected readonly keytool: KeyTool;
-
     get id(): string {
         return MarqueeTool.ID;
     }
 
     enable(): void {
-        this.keyTool.register(this.marqueeKeyListener);
-    }
-
-    disable(): void {
-        this.keyTool.deregister(this.marqueeKeyListener);
+        this.toDisposeOnDisable.push(this.keyTool.registerListener(this.marqueeKeyListener));
     }
 }
 
 @injectable()
 export class MarqueeKeyListener extends KeyListener {
-    override keyDown(element: SModelElement, event: KeyboardEvent): Action[] {
+    override keyDown(_element: SModelElement, event: KeyboardEvent): Action[] {
         if (event.shiftKey) {
             return [EnableToolsAction.create([MarqueeMouseTool.ID])];
         }

package/src/features/tools/{model.ts → marquee-selection/model.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
@@ -13,8 +13,7 @@
  *
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
-import { Point } from '@eclipse-glsp/protocol';
-import { boundsFeature, RectangularNode } from 'sprotty';
+import { boundsFeature, Point, RectangularNode } from '~glsp-sprotty';
 
 export class MarqueeNode extends RectangularNode {
     static override readonly DEFAULT_FEATURES = [boundsFeature];

package/src/features/tools/{view.tsx → marquee-selection/view.tsx}

@@ -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
@@ -15,7 +15,7 @@
  ********************************************************************************/
 import { injectable } from 'inversify';
 import { VNode } from 'snabbdom';
-import { RectangularNodeView, RenderingContext, svg } from 'sprotty';
+import { RectangularNodeView, RenderingContext, svg } from '~glsp-sprotty';
 import { MarqueeNode } from './model';
 
 // eslint-disable-next-line @typescript-eslint/no-unused-vars

package/src/features/{mouse-tool/di.config.ts → tools/node-creation/node-creation-module.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,15 +13,11 @@
  *
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
-import { ContainerModule } from 'inversify';
-import { MouseTool } from 'sprotty';
-import { TYPES } from '../../base/types';
-import { RankingMouseTool } from './mouse-tool';
+import { FeatureModule, TYPES, TriggerNodeCreationAction, bindAsService, configureActionHandler } from '~glsp-sprotty';
+import { NodeCreationTool } from './node-creation-tool';
 
-const glspMouseToolModule = new ContainerModule((bind, _unbind, _isBound, rebind) => {
-    bind(RankingMouseTool).toSelf().inSingletonScope();
-    bind(TYPES.MouseTool).toService(RankingMouseTool);
-    rebind(MouseTool).toService(RankingMouseTool);
+export const nodeCreationToolModule = new FeatureModule((bind, unbind, isBound, rebind) => {
+    const context = { bind, unbind, isBound, rebind };
+    bindAsService(context, TYPES.ITool, NodeCreationTool);
+    configureActionHandler(context, TriggerNodeCreationAction.KIND, NodeCreationTool);
 });
-
-export default glspMouseToolModule;

package/src/features/tools/{node-creation-tool.ts → node-creation/node-creation-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,57 +13,42 @@
  *
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
-import { Action, CreateNodeOperation, TriggerNodeCreationAction } from '@eclipse-glsp/protocol';
 import { inject, injectable, optional } from 'inversify';
 import {
+    Action,
+    CreateNodeOperation,
     EnableDefaultToolsAction,
-    EnableToolsAction,
-    findParentByFeature,
-    IActionHandler,
-    isCtrlOrCmd,
     ISnapper,
     SModelElement,
     SNode,
-    TYPES
-} from 'sprotty';
-import { DragAwareMouseListener } from '../../base/drag-aware-mouse-listener';
-import { getAbsolutePosition } from '../../utils/viewpoint-util';
-import { Containable, isContainable } from '../hints/model';
-import { CursorCSS, cursorFeedbackAction } from '../tool-feedback/css-feedback';
-import { BaseGLSPTool } from './base-glsp-tool';
+    TYPES,
+    TriggerNodeCreationAction,
+    findParentByFeature,
+    isCtrlOrCmd
+} from '~glsp-sprotty';
+import { DragAwareMouseListener } from '../../../base/drag-aware-mouse-listener';
+import { CursorCSS, cursorFeedbackAction } from '../../../base/feedback/css-feedback';
+import { getAbsolutePosition } from '../../../utils/viewpoint-util';
+import { Containable, isContainable } from '../../hints/model';
+import { BaseGLSPCreationTool } from '../base-glsp-creation-tool';
 
 @injectable()
-export class NodeCreationTool extends BaseGLSPTool implements IActionHandler {
+export class NodeCreationTool extends BaseGLSPCreationTool<TriggerNodeCreationAction> {
     static ID = 'tool_create_node';
 
-    @inject(TYPES.ISnapper) @optional() readonly snapper?: ISnapper;
+    protected isTriggerAction = TriggerNodeCreationAction.is;
 
-    protected creationToolMouseListener: NodeCreationToolMouseListener;
-    protected triggerAction: TriggerNodeCreationAction;
+    @inject(TYPES.ISnapper) @optional() readonly snapper?: ISnapper;
 
     get id(): string {
         return NodeCreationTool.ID;
     }
 
-    enable(): void {
-        if (this.triggerAction === undefined) {
-            throw new TypeError(`Could not enable tool ${this.id}.The triggerAction cannot be undefined.`);
-        }
-        this.creationToolMouseListener = new NodeCreationToolMouseListener(this.triggerAction, this);
-        this.mouseTool.register(this.creationToolMouseListener);
-        this.dispatchFeedback([cursorFeedbackAction(CursorCSS.NODE_CREATION)]);
-    }
-
-    disable(): void {
-        this.mouseTool.deregister(this.creationToolMouseListener);
-        this.deregisterFeedback([cursorFeedbackAction()]);
-    }
-
-    handle(action: Action): Action | void {
-        if (TriggerNodeCreationAction.is(action)) {
-            this.triggerAction = action;
-            return EnableToolsAction.create([this.id]);
-        }
+    doEnable(): void {
+        this.toDisposeOnDisable.push(
+            this.mouseTool.registerListener(new NodeCreationToolMouseListener(this.triggerAction, this)),
+            this.registerFeedback([cursorFeedbackAction(CursorCSS.NODE_CREATION)], this, [cursorFeedbackAction()])
+        );
     }
 }
 
@@ -109,7 +94,7 @@ export class NodeCreationToolMouseListener extends DragAwareMouseListener {
             const feedback = this.creationAllowed(this.elementTypeId)
                 ? cursorFeedbackAction(CursorCSS.NODE_CREATION)
                 : cursorFeedbackAction(CursorCSS.OPERATION_NOT_ALLOWED);
-            this.tool.dispatchFeedback([feedback]);
+            this.tool.registerFeedback([feedback]);
         }
         return [];
     }

package/src/features/tools/{enable-default-tools-on-focus-loss.ts → tool-focus-loss-module.ts}

@@ -1,5 +1,5 @@
 /********************************************************************************
- * Copyright (c) 2022 EclipseSource and others.
+ * Copyright (c) 2022-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,14 +13,12 @@
  *
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
-import { Action } from '@eclipse-glsp/protocol';
 import { injectable } from 'inversify';
-import { EnableDefaultToolsAction, IActionHandler, ICommand } from 'sprotty';
-import { FocusStateChangedAction } from '../../base/actions/focus-change-action';
+import { Action, EnableDefaultToolsAction, FeatureModule, IActionHandler, ICommand, configureActionHandler } from '~glsp-sprotty';
+import { FocusStateChangedAction } from '../../base/focus/focus-state-change-action';
 
 /**
  * Action handler that enables the default tools when the diagram lost focus.
- * @see FocusTracker
  * @see FocusStateChangedAction
  */
 @injectable()
@@ -31,3 +29,10 @@ export class EnableDefaultToolsOnFocusLossHandler implements IActionHandler {
         }
     }
 }
+
+/**
+ * Enables the default tools in the tool manager if the diagram looses focus.
+ */
+export const toolFocusLossModule = new FeatureModule((bind, _unbind, isBound) => {
+    configureActionHandler({ bind, isBound }, FocusStateChangedAction.KIND, EnableDefaultToolsOnFocusLossHandler);
+});