@eclipse-glsp/client 1.1.0-next.698b9de.254 → 1.1.0-next.69a77b0.259

package/src/features/tools/{edge-creation-tool.ts → edge-creation/edge-creation-tool.ts}

@@ -19,8 +19,6 @@ import {
     AnchorComputerRegistry,
     CreateEdgeOperation,
     EnableDefaultToolsAction,
-    EnableToolsAction,
-    IActionHandler,
     SEdge,
     SModelElement,
     TriggerEdgeCreationAction,
@@ -28,54 +26,39 @@ import {
     isConnectable,
     isCtrlOrCmd
 } from '~glsp-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';
+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()
+            ])
+        );
     }
 }
 
@@ -98,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[] {
@@ -107,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 })
                     ]);
                 }
@@ -117,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,
@@ -125,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/src/features/tools/edge-creation/view.tsx

@@ -0,0 +1,33 @@
+/********************************************************************************
+ * 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 { injectable } from 'inversify';
+import { VNode } from 'snabbdom';
+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.
+ */
+@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} />;
+    }
+}

package/src/features/tools/edge-edit/di.config.ts

@@ -0,0 +1,41 @@
+/********************************************************************************
+ * 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 } from '~glsp-sprotty';
+import { EdgeEditTool } from './edge-edit-tool';
+import {
+    DrawFeedbackEdgeSourceCommand,
+    HideEdgeReconnectHandlesFeedbackCommand,
+    ShowEdgeReconnectHandlesFeedbackCommand,
+    SwitchRoutingModeCommand
+} from './edge-edit-tool-feedback';
+import { configureDanglingFeedbackEdge } from '../edge-creation/dangling-edge-feedback';
+
+const edgeEditToolModule = new ContainerModule((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);
+});
+
+export default edgeEditToolModule;

package/src/features/{tool-feedback → tools/edge-edit}/edge-edit-tool-feedback.ts

@@ -21,6 +21,7 @@ import {
     Bounds,
     CommandExecutionContext,
     CommandReturn,
+    Disposable,
     EdgeRouterRegistry,
     ElementMove,
     ISnapper,
@@ -41,12 +42,14 @@ import {
     isConnectable,
     isSelected
 } from '~glsp-sprotty';
-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, FeedbackEdgeEndMovingMouseListener, feedbackEdgeEndId, feedbackEdgeId } from './creation-tool-feedback';
-import { FeedbackCommand } from './model';
+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
@@ -67,6 +70,7 @@ export namespace ShowEdgeReconnectHandlesFeedbackAction {
         return { kind: KIND, elementId };
     }
 }
+
 export interface HideEdgeReconnectHandlesFeedbackAction extends Action {
     kind: typeof HideEdgeReconnectHandlesFeedbackAction.KIND;
 }
@@ -135,6 +139,7 @@ export namespace SwitchRoutingModeAction {
         };
     }
 }
+
 @injectable()
 export class SwitchRoutingModeCommand extends SwitchEditModeCommand {
     static override KIND = SwitchRoutingModeAction.KIND;
@@ -187,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();
     }
 
@@ -207,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 [];
@@ -236,6 +245,10 @@ export class FeedbackEdgeSourceMovingMouseListener extends MouseListener {
         }
         return anchor;
     }
+
+    dispose(): void {
+        this.feedbackDispatcher.deregisterFeedback(this);
+    }
 }
 
 export class FeedbackEdgeRouteMovingMouseListener extends MouseListener {
@@ -341,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}

@@ -19,6 +19,7 @@ import {
     AnchorComputerRegistry,
     ChangeRoutingPointsOperation,
     Connectable,
+    Disposable,
     EdgeRouterRegistry,
     ISnapper,
     ReconnectEdgeOperation,
@@ -32,12 +33,13 @@ import {
     isConnectable,
     isSelected
 } from '~glsp-sprotty';
-import { DragAwareMouseListener } from '../../base/drag-aware-mouse-listener';
-import { calcElementAndRoutingPoints, isRoutable, isRoutingHandle } from '../../utils/smodel-util';
-import { SReconnectHandle, isReconnectHandle, isReconnectable, isSourceRoutingHandle, isTargetRoutingHandle } from '../reconnect/model';
-import { SelectionListener, SelectionService } from '../select/selection-service';
-import { DrawFeedbackEdgeAction, RemoveFeedbackEdgeAction, feedbackEdgeId } from '../tool-feedback/creation-tool-feedback';
-import { CursorCSS, cursorFeedbackAction } from '../tool-feedback/css-feedback';
+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,
@@ -46,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;
@@ -69,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 {
@@ -85,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;
@@ -132,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 {
@@ -142,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 })
@@ -257,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 [];
@@ -314,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/enable-default-tools-on-focus-loss.ts

@@ -13,8 +13,8 @@
  *
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
-import { injectable } from 'inversify';
-import { Action, EnableDefaultToolsAction, IActionHandler, ICommand } from '~glsp-sprotty';
+import { ContainerModule, injectable } from 'inversify';
+import { Action, EnableDefaultToolsAction, IActionHandler, ICommand, configureActionHandler } from '~glsp-sprotty';
 import { FocusStateChangedAction } from '../../base/actions/focus-change-action';
 
 /**
@@ -30,3 +30,12 @@ export class EnableDefaultToolsOnFocusLossHandler implements IActionHandler {
         }
     }
 }
+
+/**
+ * Enables the default tools in the tool manager if the diagram looses focus.
+ */
+const enableDefaultToolsOnFocusLossModule = new ContainerModule((bind, _unbind, isBound) => {
+    configureActionHandler({ bind, isBound }, FocusStateChangedAction.KIND, EnableDefaultToolsOnFocusLossHandler);
+});
+
+export default enableDefaultToolsOnFocusLossModule;

package/src/features/tools/marquee-selection/di.config.ts

@@ -0,0 +1,35 @@
+/********************************************************************************
+ * 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, 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';
+
+const marqueeSelectionToolModule = new ContainerModule((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);
+});
+
+export default marqueeSelectionToolModule;

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

@@ -15,7 +15,7 @@
  ********************************************************************************/
 
 import { Bounds, Point, PointToPointLine } from '~glsp-sprotty';
-import { DrawMarqueeAction } from '../tool-feedback/marquee-tool-feedback';
+import { DrawMarqueeAction } from './marquee-tool-feedback';
 
 export interface IMarqueeBehavior {
     readonly entireElement: boolean;
@@ -77,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;
@@ -86,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;
@@ -95,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) ||
@@ -107,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)
@@ -123,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) {
@@ -137,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) {
@@ -151,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}

@@ -29,12 +29,12 @@ import {
     isSelectable,
     isSelected
 } from '~glsp-sprotty';
-import { DragAwareMouseListener } from '../../base/drag-aware-mouse-listener';
-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';
+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 {
@@ -43,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 {
@@ -51,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()])
+        );
     }
 }
 
@@ -119,7 +113,7 @@ export class MarqueeMouseListener extends DragAwareMouseListener {
         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/{tool-feedback → tools/marquee-selection}/marquee-tool-feedback.ts

@@ -27,7 +27,7 @@ import {
     TYPES,
     hasObjectProp
 } from '~glsp-sprotty';
-import { FeedbackCommand } from './model';
+import { FeedbackCommand } from '../../../base/feedback/feedback-command';
 
 export interface DrawMarqueeAction extends Action {
     kind: typeof DrawMarqueeAction.KIND;