@eclipse-glsp/client 1.1.0-next.a07a5f7.197 → 1.1.0-next.a6d39b4.266

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

@@ -1,74 +0,0 @@
-/********************************************************************************
- * Copyright (c) 2019-2022 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 { TriggerEdgeCreationAction, TriggerNodeCreationAction } from '@eclipse-glsp/protocol';
-import { ContainerModule, interfaces } from 'inversify';
-import { configureActionHandler, configureModelElement, ManhattanEdgeRouter } from 'sprotty';
-import { FocusStateChangedAction } from '../../base/actions/focus-change-action';
-import { TYPES } from '../../base/types';
-import { GLSPSvgExporter } from '../export/glsp-svg-exporter';
-import { MARQUEE } from '../tool-feedback/marquee-tool-feedback';
-import { ChangeBoundsTool } from './change-bounds-tool';
-import { DelKeyDeleteTool, MouseDeleteTool } from './delete-tool';
-import { EdgeCreationTool } from './edge-creation-tool';
-import { EdgeEditTool } from './edge-edit-tool';
-import { EnableDefaultToolsOnFocusLossHandler } from './enable-default-tools-on-focus-loss';
-import { GSLPManhattanEdgeRouter } from './glsp-manhattan-edge-router';
-import { MarqueeMouseTool } from './marquee-mouse-tool';
-import { MarqueeTool } from './marquee-tool';
-import { MarqueeNode } from './model';
-import { NodeCreationTool } from './node-creation-tool';
-import { MarqueeView } from './view';
-
-/**
- * Registers the default tools of GLSP (node and edge creation, changing bounds, edge editing, deletion)
- * and adds the marquee selection tool.
- */
-export const toolsModule = new ContainerModule((bind, _unbind, isBound, rebind) => {
-    // Register default tools
-    bind(TYPES.IDefaultTool).to(ChangeBoundsTool);
-    bind(TYPES.IDefaultTool).to(EdgeEditTool);
-    bind(TYPES.IDefaultTool).to(DelKeyDeleteTool);
-
-    // Register  tools
-    bind(TYPES.ITool).to(MouseDeleteTool);
-    bind(NodeCreationTool).toSelf().inSingletonScope();
-    bind(EdgeCreationTool).toSelf().inSingletonScope();
-    bind(TYPES.ITool).toService(EdgeCreationTool);
-    bind(TYPES.ITool).toService(NodeCreationTool);
-
-    configureMarqueeTool({ bind, isBound });
-    configureActionHandler({ bind, isBound }, TriggerNodeCreationAction.KIND, NodeCreationTool);
-    configureActionHandler({ bind, isBound }, TriggerEdgeCreationAction.KIND, EdgeCreationTool);
-
-    bind(GLSPSvgExporter).toSelf().inSingletonScope();
-    rebind(TYPES.SvgExporter).toService(GLSPSvgExporter);
-
-    bind(GSLPManhattanEdgeRouter).toSelf().inSingletonScope();
-    rebind(ManhattanEdgeRouter).toService(GSLPManhattanEdgeRouter);
-});
-
-export function configureMarqueeTool(context: { bind: interfaces.Bind; isBound: interfaces.IsBound }): void {
-    configureModelElement(context, MARQUEE, MarqueeNode, MarqueeView);
-    context.bind(TYPES.IDefaultTool).to(MarqueeTool);
-    context.bind(TYPES.ITool).to(MarqueeMouseTool);
-}
-
-/**
- * Enables the default tools in the tool manager if the diagram looses focus.
- */
-export const enableDefaultToolsOnFocusLossModule = new ContainerModule((bind, _unbind, isBound) => {
-    configureActionHandler({ bind, isBound }, FocusStateChangedAction.KIND, EnableDefaultToolsOnFocusLossHandler);
-});

package/src/features/tools/edge-creation-tool.ts

@@ -1,175 +0,0 @@
-/********************************************************************************
- * Copyright (c) 2019-2022 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 { Action, CreateEdgeOperation, TriggerEdgeCreationAction } from '@eclipse-glsp/protocol';
-import { inject, injectable } from 'inversify';
-import {
-    AnchorComputerRegistry,
-    EnableDefaultToolsAction,
-    EnableToolsAction,
-    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';
-
-/**
- * Tool to create connections in a Diagram, by selecting a source and target node.
- */
-@injectable()
-export class EdgeCreationTool extends BaseGLSPTool implements IActionHandler {
-    static ID = 'tool_create_edge';
-
-    @inject(AnchorComputerRegistry) protected anchorRegistry: AnchorComputerRegistry;
-
-    protected triggerAction: TriggerEdgeCreationAction;
-    protected creationToolMouseListener: EdgeCreationToolMouseListener;
-    protected feedbackEndMovingMouseListener: FeedbackEdgeEndMovingMouseListener;
-
-    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]);
-        }
-    }
-}
-
-@injectable()
-export class EdgeCreationToolMouseListener extends DragAwareMouseListener {
-    protected source?: string;
-    protected target?: string;
-    protected currentTarget?: SModelElement;
-    protected allowedTarget = false;
-    protected proxyEdge: SEdge;
-
-    constructor(protected triggerAction: TriggerEdgeCreationAction, protected tool: EdgeCreationTool) {
-        super();
-        this.proxyEdge = new SEdge();
-        this.proxyEdge.type = triggerAction.elementTypeId;
-    }
-
-    protected reinitialize(): void {
-        this.source = undefined;
-        this.target = undefined;
-        this.currentTarget = undefined;
-        this.allowedTarget = false;
-        this.tool.dispatchFeedback([RemoveFeedbackEdgeAction.create()]);
-    }
-
-    override nonDraggingMouseUp(_element: SModelElement, event: MouseEvent): Action[] {
-        const result: Action[] = [];
-        if (event.button === 0) {
-            if (!this.isSourceSelected()) {
-                if (this.currentTarget && this.allowedTarget) {
-                    this.source = this.currentTarget.id;
-                    this.tool.dispatchFeedback([
-                        DrawFeedbackEdgeAction.create({ elementTypeId: this.triggerAction.elementTypeId, sourceId: this.source })
-                    ]);
-                }
-            } else {
-                if (this.currentTarget && this.allowedTarget) {
-                    this.target = this.currentTarget.id;
-                }
-            }
-            if (this.source && this.target) {
-                result.push(
-                    CreateEdgeOperation.create({
-                        elementTypeId: this.triggerAction.elementTypeId,
-                        sourceElementId: this.source,
-                        targetElementId: this.target,
-                        args: this.triggerAction.args
-                    })
-                );
-                if (!isCtrlOrCmd(event)) {
-                    result.push(EnableDefaultToolsAction.create());
-                } else {
-                    this.reinitialize();
-                }
-            }
-        } else if (event.button === 2) {
-            result.push(EnableDefaultToolsAction.create());
-        }
-        return result;
-    }
-
-    protected isSourceSelected(): boolean {
-        return this.source !== undefined;
-    }
-
-    protected isTargetSelected(): boolean {
-        return this.target !== undefined;
-    }
-
-    override mouseOver(target: SModelElement, event: MouseEvent): Action[] {
-        const newCurrentTarget = findParentByFeature(target, isConnectable);
-        if (newCurrentTarget !== this.currentTarget) {
-            this.currentTarget = newCurrentTarget;
-            if (this.currentTarget) {
-                if (!this.isSourceSelected()) {
-                    this.allowedTarget = this.isAllowedSource(newCurrentTarget);
-                } else if (!this.isTargetSelected()) {
-                    this.allowedTarget = this.isAllowedTarget(newCurrentTarget);
-                }
-                if (this.allowedTarget) {
-                    const action = !this.isSourceSelected()
-                        ? cursorFeedbackAction(CursorCSS.EDGE_CREATION_SOURCE)
-                        : cursorFeedbackAction(CursorCSS.EDGE_CREATION_TARGET);
-                    return [action];
-                }
-            }
-            return [cursorFeedbackAction(CursorCSS.OPERATION_NOT_ALLOWED)];
-        }
-        return [];
-    }
-
-    protected isAllowedSource(element: SModelElement | undefined): boolean {
-        return element !== undefined && isConnectable(element) && element.canConnect(this.proxyEdge, 'source');
-    }
-
-    protected isAllowedTarget(element: SModelElement | undefined): boolean {
-        return element !== undefined && isConnectable(element) && element.canConnect(this.proxyEdge, 'target');
-    }
-}

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

@@ -1,318 +0,0 @@
-/********************************************************************************
- * Copyright (c) 2019-2022 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 { Action, ChangeRoutingPointsOperation, ReconnectEdgeOperation } from '@eclipse-glsp/protocol';
-import { inject, injectable, optional } from 'inversify';
-import {
-    AnchorComputerRegistry,
-    canEditRouting,
-    Connectable,
-    EdgeRouterRegistry,
-    findParentByFeature,
-    isConnectable,
-    ISnapper,
-    isSelected,
-    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';
-import {
-    DrawFeedbackEdgeSourceAction,
-    FeedbackEdgeRouteMovingMouseListener,
-    FeedbackEdgeSourceMovingMouseListener,
-    FeedbackEdgeTargetMovingMouseListener,
-    HideEdgeReconnectHandlesFeedbackAction,
-    ShowEdgeReconnectHandlesFeedbackAction,
-    SwitchRoutingModeAction
-} from '../tool-feedback/edge-edit-tool-feedback';
-import { BaseGLSPTool } from './base-glsp-tool';
-
-@injectable()
-export class EdgeEditTool extends BaseGLSPTool {
-    static ID = 'glsp.edge-edit-tool';
-
-    @inject(TYPES.SelectionService) protected selectionService: SelectionService;
-    @inject(AnchorComputerRegistry) protected anchorRegistry: AnchorComputerRegistry;
-    @inject(EdgeRouterRegistry) @optional() readonly edgeRouterRegistry?: EdgeRouterRegistry;
-    @inject(TYPES.ISnapper) @optional() readonly snapper?: ISnapper;
-
-    protected feedbackEdgeSourceMovingListener: FeedbackEdgeSourceMovingMouseListener;
-    protected feedbackEdgeTargetMovingListener: FeedbackEdgeTargetMovingMouseListener;
-    protected feedbackMovingListener: FeedbackEdgeRouteMovingMouseListener;
-    protected edgeEditListener: EdgeEditListener;
-
-    get id(): string {
-        return EdgeEditTool.ID;
-    }
-
-    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.feedbackMovingListener = new FeedbackEdgeRouteMovingMouseListener(this.edgeRouterRegistry, this.snapper);
-    }
-
-    registerFeedbackListeners(): void {
-        this.mouseTool.register(this.feedbackMovingListener);
-        this.mouseTool.register(this.feedbackEdgeSourceMovingListener);
-        this.mouseTool.register(this.feedbackEdgeTargetMovingListener);
-    }
-
-    deregisterFeedbackListeners(): void {
-        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 {
-    // active selection data
-    protected edge?: SRoutableElement;
-    protected routingHandle?: SRoutingHandle;
-
-    // new connectable (source or target) for edge
-    protected newConnectable?: SModelElement & Connectable;
-
-    // active reconnect handle data
-    protected reconnectMode?: 'NEW_SOURCE' | 'NEW_TARGET';
-
-    constructor(protected tool: EdgeEditTool) {
-        super();
-    }
-
-    protected isValidEdge(edge?: SRoutableElement): edge is SRoutableElement {
-        return edge !== undefined && edge.id !== feedbackEdgeId(edge.root) && isSelected(edge);
-    }
-
-    protected setEdgeSelected(edge: SRoutableElement): void {
-        if (this.edge && this.edge.id !== edge.id) {
-            // reset from a previously selected edge
-            this.reset();
-        }
-
-        this.edge = edge;
-        // note: order is important here as we want the reconnect handles to cover the routing handles
-        const feedbackActions = [];
-        if (canEditRouting(edge)) {
-            feedbackActions.push(SwitchRoutingModeAction.create({ elementsToActivate: [this.edge.id] }));
-        }
-        if (isReconnectable(edge)) {
-            feedbackActions.push(ShowEdgeReconnectHandlesFeedbackAction.create(this.edge.id));
-        }
-        this.tool.dispatchFeedback(feedbackActions);
-    }
-
-    protected isEdgeSelected(): boolean {
-        return this.edge !== undefined && isSelected(this.edge);
-    }
-
-    protected setReconnectHandleSelected(edge: SRoutableElement, reconnectHandle: SReconnectHandle): void {
-        if (this.edge && this.edge.target && this.edge.source) {
-            if (isSourceRoutingHandle(edge, reconnectHandle)) {
-                this.tool.dispatchFeedback([
-                    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([
-                    HideEdgeReconnectHandlesFeedbackAction.create(),
-                    cursorFeedbackAction(CursorCSS.EDGE_CREATION_TARGET),
-                    DrawFeedbackEdgeAction.create({ elementTypeId: this.edge.type, sourceId: this.edge.sourceId })
-                ]);
-                this.reconnectMode = 'NEW_TARGET';
-            }
-        }
-    }
-
-    protected isReconnecting(): boolean {
-        return this.reconnectMode !== undefined;
-    }
-
-    protected isReconnectingNewSource(): boolean {
-        return this.reconnectMode === 'NEW_SOURCE';
-    }
-
-    protected setRoutingHandleSelected(edge: SRoutableElement, routingHandle: SRoutingHandle): void {
-        if (this.edge && this.edge.target && this.edge.source) {
-            this.routingHandle = routingHandle;
-        }
-    }
-
-    protected requiresReconnect(sourceId: string, targetId: string): boolean {
-        return this.edge !== undefined && (this.edge.sourceId !== sourceId || this.edge.targetId !== targetId);
-    }
-
-    protected setNewConnectable(connectable?: SModelElement & Connectable): void {
-        this.newConnectable = connectable;
-    }
-
-    protected isReadyToReconnect(): boolean | undefined {
-        return this.edge && this.isReconnecting() && this.newConnectable !== undefined;
-    }
-
-    protected isReadyToReroute(): boolean {
-        return this.routingHandle !== undefined;
-    }
-
-    override mouseDown(target: SModelElement, event: MouseEvent): Action[] {
-        const result: Action[] = super.mouseDown(target, event);
-        if (event.button === 0) {
-            const reconnectHandle = findParentByFeature(target, isReconnectHandle);
-            const routingHandle = !reconnectHandle ? findParentByFeature(target, isRoutingHandle) : undefined;
-            const edge = findParentByFeature(target, isRoutable);
-            if (this.isEdgeSelected() && edge && reconnectHandle) {
-                // PHASE 2 Reconnect: Select reconnect handle on selected edge
-                this.setReconnectHandleSelected(edge, reconnectHandle);
-            } else if (this.isEdgeSelected() && edge && routingHandle) {
-                // PHASE 2 Reroute: Select routing handle on selected edge
-                this.setRoutingHandleSelected(edge, routingHandle);
-            } else if (this.isValidEdge(edge)) {
-                // PHASE 1: Select edge
-                this.tool.registerFeedbackListeners();
-                this.setEdgeSelected(edge);
-            }
-        } else if (event.button === 2) {
-            this.reset();
-        }
-        return result;
-    }
-
-    override mouseMove(target: SModelElement, event: MouseEvent): Action[] {
-        const result = super.mouseMove(target, event);
-        if (this.isMouseDrag) {
-            // reset any selected connectables when we are dragging, maybe the user is just panning
-            this.setNewConnectable(undefined);
-        }
-        return result;
-    }
-
-    override mouseUp(target: SModelElement, event: MouseEvent): Action[] {
-        const result = super.mouseUp(target, event);
-        if (!this.isReadyToReconnect() && !this.isReadyToReroute()) {
-            return result;
-        }
-
-        if (this.edge && this.newConnectable) {
-            const sourceElementId = this.isReconnectingNewSource() ? this.newConnectable.id : this.edge.sourceId;
-            const targetElementId = this.isReconnectingNewSource() ? this.edge.targetId : this.newConnectable.id;
-            if (this.requiresReconnect(sourceElementId, targetElementId)) {
-                result.push(ReconnectEdgeOperation.create({ edgeElementId: this.edge.id, sourceElementId, targetElementId }));
-            }
-            this.reset();
-        } else if (this.edge && this.routingHandle) {
-            // we need to re-retrieve the edge as it might have changed due to a server update since we do not reset the state between
-            // reroute actions
-            const latestEdge = target.index.getById(this.edge.id);
-            if (latestEdge && isRoutable(latestEdge)) {
-                const newRoutingPoints = calcElementAndRoutingPoints(latestEdge, this.tool.edgeRouterRegistry);
-                result.push(ChangeRoutingPointsOperation.create([newRoutingPoints]));
-                this.routingHandle = undefined;
-            }
-        }
-        return result;
-    }
-
-    override mouseOver(target: SModelElement, _event: MouseEvent): Action[] {
-        if (this.edge && this.isReconnecting()) {
-            const currentTarget = findParentByFeature(target, isConnectable);
-            if (!this.newConnectable || currentTarget !== this.newConnectable) {
-                this.setNewConnectable(currentTarget);
-                if (currentTarget) {
-                    if (
-                        (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)]);
-                        return [];
-                    }
-                }
-                this.tool.dispatchFeedback([cursorFeedbackAction(CursorCSS.OPERATION_NOT_ALLOWED)]);
-            }
-        }
-        return [];
-    }
-
-    selectionChanged(root: Readonly<SModelRoot>, selectedElements: string[]): void {
-        if (this.edge) {
-            if (selectedElements.indexOf(this.edge.id) > -1) {
-                // our active edge is still selected, nothing to do
-                return;
-            }
-
-            if (this.isReconnecting()) {
-                // we are reconnecting, so we may have clicked on a potential target
-                return;
-            }
-
-            // try to find some other selected element and mark that active
-            for (const elementId of selectedElements.reverse()) {
-                const element = root.index.getById(elementId);
-                if (element) {
-                    const edge = findParentByFeature(element, isRoutable);
-                    if (this.isValidEdge(edge)) {
-                        // PHASE 1: Select edge
-                        this.setEdgeSelected(edge);
-                        return;
-                    }
-                }
-            }
-
-            this.reset();
-        }
-    }
-
-    public reset(): void {
-        this.resetFeedback();
-        this.resetData();
-    }
-
-    protected resetData(): void {
-        this.edge = undefined;
-        this.reconnectMode = undefined;
-        this.newConnectable = undefined;
-        this.routingHandle = undefined;
-    }
-
-    protected resetFeedback(): void {
-        const result: Action[] = [];
-        if (this.edge) {
-            result.push(SwitchRoutingModeAction.create({ elementsToDeactivate: [this.edge.id] }));
-        }
-        result.push(...[HideEdgeReconnectHandlesFeedbackAction.create(), cursorFeedbackAction(), RemoveFeedbackEdgeAction.create()]);
-        this.tool.deregisterFeedback(result);
-        this.tool.deregisterFeedbackListeners();
-    }
-}

package/src/features/tools/enable-default-tools-on-focus-loss.ts

@@ -1,33 +0,0 @@
-/********************************************************************************
- * Copyright (c) 2022 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 { Action } from '@eclipse-glsp/protocol';
-import { injectable } from 'inversify';
-import { EnableDefaultToolsAction, IActionHandler, ICommand } from 'sprotty';
-import { FocusStateChangedAction } from '../../base/actions/focus-change-action';
-
-/**
- * Action handler that enables the default tools when the diagram lost focus.
- * @see FocusTracker
- * @see FocusStateChangedAction
- */
-@injectable()
-export class EnableDefaultToolsOnFocusLossHandler implements IActionHandler {
-    handle(action: Action): void | Action | ICommand {
-        if (FocusStateChangedAction.is(action) && !action.hasFocus) {
-            return EnableDefaultToolsAction.create();
-        }
-    }
-}

package/src/features/tools/glsp-manhattan-edge-router.ts

@@ -1,57 +0,0 @@
-/********************************************************************************
- * Copyright (c) 2022 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 { almostEquals } from '@eclipse-glsp/protocol';
-import { ManhattanEdgeRouter, ResolvedHandleMove, SRoutableElement } from 'sprotty';
-
-export class GSLPManhattanEdgeRouter extends ManhattanEdgeRouter {
-    protected override applyInnerHandleMoves(edge: SRoutableElement, moves: ResolvedHandleMove[]): void {
-        const route = this.route(edge);
-        const routingPoints = edge.routingPoints;
-        const minimalPointDistance = this.getOptions(edge).minimalPointDistance;
-        moves.forEach(move => {
-            const handle = move.handle;
-            const index = handle.pointIndex;
-            const correctedX = this.correctX(routingPoints, index, move.toPosition.x, minimalPointDistance);
-            const correctedY = this.correctY(routingPoints, index, move.toPosition.y, minimalPointDistance);
-            switch (handle.kind) {
-                case 'manhattan-50%':
-                    if (index < 0) {
-                        if (routingPoints.length === 0) {
-                            routingPoints.push({ x: correctedX, y: correctedY });
-                            move.handle.pointIndex = 0;
-                        }
-                        else if (almostEquals(route[0].x, route[1].x)) { this.alignX(routingPoints, 0, correctedX); }
-                        else { this.alignY(routingPoints, 0, correctedY); }
-                    } else if (index < routingPoints.length - 1) {
-                        if (almostEquals(routingPoints[index].x, routingPoints[index + 1].x)) {
-                            this.alignX(routingPoints, index, correctedX);
-                            this.alignX(routingPoints, index + 1, correctedX);
-                        } else {
-                            this.alignY(routingPoints, index, correctedY);
-                            this.alignY(routingPoints, index + 1, correctedY);
-                        }
-                    } else {
-                        if (almostEquals(route[route.length - 2].x, route[route.length - 1].x)) {
-                            this.alignX(routingPoints, routingPoints.length - 1, correctedX);
-                        }
-                        else { this.alignY(routingPoints, routingPoints.length - 1, correctedY); }
-                    }
-                    break;
-            }
-        });
-    }
-}