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

package/src/features/routing/di.config.ts

@@ -0,0 +1,82 @@
+/********************************************************************************
+ * 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 {
+    AddRemoveBezierSegmentCommand,
+    AnchorComputerRegistry,
+    BezierDiamondAnchor,
+    BezierEdgeRouter,
+    BezierEllipseAnchor,
+    BezierRectangleAnchor,
+    DiamondAnchor,
+    EdgeRouterRegistry,
+    EllipseAnchor,
+    ManhattanDiamondAnchor,
+    ManhattanEdgeRouter,
+    ManhattanEllipticAnchor,
+    ManhattanRectangularAnchor,
+    PolylineEdgeRouter,
+    RectangleAnchor,
+    TYPES,
+    bindOrRebind,
+    configureCommand
+} from '~glsp-sprotty';
+import { GLSPManhattanEdgeRouter } from './glsp-manhattan-edge-router';
+
+/**
+ * Customization of the routing module for GLSP.
+ */
+const glspRoutingModule = new ContainerModule((bind, _unbind, isBound, rebind) => {
+    const context = { bind, isBound, rebind };
+
+    bind(EdgeRouterRegistry).toSelf().inSingletonScope();
+
+    bind(AnchorComputerRegistry).toSelf().inSingletonScope();
+
+    bind(GLSPManhattanEdgeRouter).toSelf().inSingletonScope();
+    bind(ManhattanEdgeRouter).toService(GLSPManhattanEdgeRouter);
+    bind(TYPES.IEdgeRouter).toService(ManhattanEdgeRouter);
+    bind(ManhattanEllipticAnchor).toSelf().inSingletonScope();
+    bind(TYPES.IAnchorComputer).toService(ManhattanEllipticAnchor);
+    bind(ManhattanRectangularAnchor).toSelf().inSingletonScope();
+    bind(TYPES.IAnchorComputer).toService(ManhattanRectangularAnchor);
+    bind(ManhattanDiamondAnchor).toSelf().inSingletonScope();
+    bind(TYPES.IAnchorComputer).toService(ManhattanDiamondAnchor);
+
+    bind(PolylineEdgeRouter).toSelf().inSingletonScope();
+    bind(TYPES.IEdgeRouter).toService(PolylineEdgeRouter);
+    bind(EllipseAnchor).toSelf().inSingletonScope();
+    bind(TYPES.IAnchorComputer).toService(EllipseAnchor);
+    bind(RectangleAnchor).toSelf().inSingletonScope();
+    bind(TYPES.IAnchorComputer).toService(RectangleAnchor);
+    bind(DiamondAnchor).toSelf().inSingletonScope();
+    bind(TYPES.IAnchorComputer).toService(DiamondAnchor);
+
+    bind(BezierEdgeRouter).toSelf().inSingletonScope();
+    bind(TYPES.IEdgeRouter).toService(BezierEdgeRouter);
+    bind(BezierEllipseAnchor).toSelf().inSingletonScope();
+    bind(TYPES.IAnchorComputer).toService(BezierEllipseAnchor);
+    bind(BezierRectangleAnchor).toSelf().inSingletonScope();
+    bind(TYPES.IAnchorComputer).toService(BezierRectangleAnchor);
+    bind(BezierDiamondAnchor).toSelf().inSingletonScope();
+    bind(TYPES.IAnchorComputer).toService(BezierDiamondAnchor);
+
+    configureCommand({ bind, isBound }, AddRemoveBezierSegmentCommand);
+
+    bindOrRebind(context, ManhattanEdgeRouter).toService(GLSPManhattanEdgeRouter);
+});
+
+export default glspRoutingModule;

package/src/features/select/di.config.ts

@@ -15,18 +15,16 @@
  ********************************************************************************/
 import { ContainerModule } from 'inversify';
 import { TYPES, bindAsService, configureCommand } from '~glsp-sprotty';
-import { SelectFeedbackCommand } from './select-feedback-action';
+import { SelectAllCommand, SelectCommand } from '../../base/selection-service';
+import { SelectFeedbackCommand } from './select-feedback-command';
 import { RankedSelectMouseListener } from './select-mouse-listener';
-import { SelectAllCommand, SelectCommand, SelectionService } from './selection-service';
 
 const glspSelectModule = new ContainerModule((bind, _unbind, isBound) => {
     const context = { bind, isBound };
-    bindAsService(context, TYPES.SelectionService, SelectionService);
     configureCommand(context, SelectCommand);
     configureCommand(context, SelectAllCommand);
     configureCommand(context, SelectFeedbackCommand);
     bindAsService(context, TYPES.MouseListener, RankedSelectMouseListener);
-    bind(TYPES.SModelRootListener).toService(SelectionService);
 });
 
 export default glspSelectModule;

package/src/features/select/{select-feedback-action.ts → select-feedback-command.ts}

@@ -14,44 +14,8 @@
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
 import { inject, injectable } from 'inversify';
-import {
-    Action,
-    Command,
-    CommandExecutionContext,
-    SModelRoot,
-    SelectAction,
-    SprottySelectCommand,
-    TYPES,
-    hasArrayProp
-} from '~glsp-sprotty';
-
-export interface SelectFeedbackAction extends Omit<SelectAction, 'kind'>, Action {
-    kind: typeof SelectFeedbackAction.KIND;
-}
-
-export namespace SelectFeedbackAction {
-    export const KIND = 'selectFeedback';
-
-    export function is(object: any): object is SelectFeedbackAction {
-        return Action.hasKind(object, KIND) && hasArrayProp(object, 'selectedElementsIDs') && hasArrayProp(object, 'deselectedElementsIDs');
-    }
-
-    export function create(options?: { selectedElementsIDs?: string[]; deselectedElementsIDs?: string[] | boolean }): SelectFeedbackAction {
-        return { ...SelectAction.create(options), kind: KIND };
-    }
-
-    export function addSelection(selectedElementsIDs: string[]): SelectFeedbackAction {
-        return { ...SelectAction.addSelection(selectedElementsIDs), kind: KIND };
-    }
-
-    export function removeSelection(deselectedElementsIDs: string[]): SelectFeedbackAction {
-        return { ...SelectAction.removeSelection(deselectedElementsIDs), kind: KIND };
-    }
-
-    export function setSelection(selectedElementsIDs: string[]): SelectFeedbackAction {
-        return { ...SelectAction.setSelection(selectedElementsIDs), kind: KIND };
-    }
-}
+import { Command, CommandExecutionContext, SModelRoot, SelectAction, SprottySelectCommand, TYPES } from '~glsp-sprotty';
+import { SelectFeedbackAction } from '../../base/selection-service';
 
 @injectable()
 export class SelectFeedbackCommand extends Command {

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

@@ -29,14 +29,14 @@ import {
     isSelectable,
     toArray
 } from '~glsp-sprotty';
-import { DEFAULT_RANK, Ranked } from '../rank/model';
+import { Ranked } from '../../base/ranked';
 
 /**
  * Ranked select mouse listener that is executed before default mouse listeners when using the RankedMouseTool.
  * This ensures that default mouse listeners are working on a model that has selection changes already applied.
  */
 export class RankedSelectMouseListener extends SelectMouseListener implements Ranked {
-    rank: number = DEFAULT_RANK - 1; /* we want to be executed before all default mouse listeners */
+    rank: number = Ranked.DEFAULT_RANK - 1; /* we want to be executed before all default mouse listeners */
 
     override mouseDown(target: SModelElement, event: MouseEvent): (Action | Promise<Action>)[] {
         const result: Action[] = [];

package/src/features/source-model-watcher/source-model-changed-action-handler.ts

@@ -70,7 +70,7 @@ export class SourceModelChangedActionHandler implements IActionHandler {
         const severity = 'WARNING';
         this.dispatcher.dispatchAll([
             ServerStatusAction.create(message, { severity, timeout }),
-            ServerMessageAction.create(message, { severity, timeout })
+            ServerMessageAction.create(message, { severity })
         ]);
     }
 }

package/src/features/tool-palette/tool-palette.ts

@@ -34,10 +34,10 @@ import {
     matchesKeystroke
 } from '~glsp-sprotty';
 import { GLSPActionDispatcher } from '../../base/action-dispatcher';
-import { EditModeListener, EditorContextService } from '../../base/editor-context-service';
+import { EditorContextService, IEditModeListener } from '../../base/editor-context-service';
 import { FocusTracker } from '../../base/focus-tracker';
-import { MouseDeleteTool } from '../tools/delete-tool';
-import { MarqueeMouseTool } from '../tools/marquee-mouse-tool';
+import { MouseDeleteTool } from '../tools/deletion/delete-tool';
+import { MarqueeMouseTool } from '../tools/marquee-selection/marquee-mouse-tool';
 
 const CLICKED_CSS_CLASS = 'clicked';
 const SEARCH_ICON_ID = 'search';
@@ -61,7 +61,7 @@ export namespace EnableToolPaletteAction {
     }
 }
 @injectable()
-export class ToolPalette extends AbstractUIExtension implements IActionHandler, EditModeListener {
+export class ToolPalette extends AbstractUIExtension implements IActionHandler, IEditModeListener {
     static readonly ID = 'tool-palette';
 
     @inject(TYPES.IActionDispatcher) protected readonly actionDispatcher: GLSPActionDispatcher;
@@ -72,7 +72,7 @@ export class ToolPalette extends AbstractUIExtension implements IActionHandler,
     protected paletteItems: PaletteItem[];
     protected paletteItemsCopy: PaletteItem[] = [];
     protected bodyDiv?: HTMLElement;
-    protected lastActivebutton?: HTMLElement;
+    protected lastActiveButton?: HTMLElement;
     protected defaultToolsButton: HTMLElement;
     protected searchField: HTMLInputElement;
     modelRootId: string;
@@ -86,7 +86,7 @@ export class ToolPalette extends AbstractUIExtension implements IActionHandler,
 
     @postConstruct()
     postConstruct(): void {
-        this.editorContext.register(this);
+        this.editorContext.onEditModeChanged(change => this.editModeChanged(change.newValue, change.oldValue));
     }
 
     override initialize(): boolean {
@@ -99,7 +99,7 @@ export class ToolPalette extends AbstractUIExtension implements IActionHandler,
     protected initializeContents(_containerElement: HTMLElement): void {
         this.createHeader();
         this.createBody();
-        this.lastActivebutton = this.defaultToolsButton;
+        this.lastActiveButton = this.defaultToolsButton;
     }
 
     protected override onBeforeShow(_containerElement: HTMLElement, root: Readonly<SModelRoot>): void {
@@ -307,15 +307,15 @@ export class ToolPalette extends AbstractUIExtension implements IActionHandler,
     }
 
     changeActiveButton(button?: HTMLElement): void {
-        if (this.lastActivebutton) {
-            this.lastActivebutton.classList.remove(CLICKED_CSS_CLASS);
+        if (this.lastActiveButton) {
+            this.lastActiveButton.classList.remove(CLICKED_CSS_CLASS);
         }
         if (button) {
             button.classList.add(CLICKED_CSS_CLASS);
-            this.lastActivebutton = button;
+            this.lastActiveButton = button;
         } else if (this.defaultToolsButton) {
             this.defaultToolsButton.classList.add(CLICKED_CSS_CLASS);
-            this.lastActivebutton = this.defaultToolsButton;
+            this.lastActiveButton = this.defaultToolsButton;
         }
     }
 
@@ -344,7 +344,7 @@ export class ToolPalette extends AbstractUIExtension implements IActionHandler,
         }
     }
 
-    editModeChanged(_oldValue: string, _newValue: string): void {
+    editModeChanged(_newValue: string, _oldValue: string): void {
         this.actionDispatcher.dispatch(
             SetUIExtensionVisibilityAction.create({ extensionId: ToolPalette.ID, visible: !this.editorContext.isReadonly })
         );

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

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

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

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

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

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