@eclipse-glsp/client 1.1.0-next.fe0b297.182 → 2.0.0

package/src/features/tools/delete-tool.ts

@@ -1,123 +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, DeleteElementOperation } from '@eclipse-glsp/protocol';
-import { inject, injectable } from 'inversify';
-import {
-    EnableDefaultToolsAction,
-    findParentByFeature,
-    isCtrlOrCmd,
-    isDeletable,
-    isSelectable,
-    KeyListener,
-    KeyTool,
-    MouseListener,
-    SModelElement
-} from 'sprotty';
-import { matchesKeystroke } from 'sprotty/lib/utils/keyboard';
-import { GLSPTool } from '../../base/tool-manager/glsp-tool-manager';
-import { TYPES } from '../../base/types';
-import { IMouseTool } from '../mouse-tool/mouse-tool';
-import { CursorCSS, cursorFeedbackAction } from '../tool-feedback/css-feedback';
-import { IFeedbackActionDispatcher } from '../tool-feedback/feedback-action-dispatcher';
-
-/**
- * Deletes selected elements when hitting the `Del` key.
- */
-@injectable()
-export class DelKeyDeleteTool implements GLSPTool {
-    static ID = 'glsp.delete-keyboard';
-
-    isEditTool = true;
-    protected deleteKeyListener: DeleteKeyListener = new DeleteKeyListener();
-
-    @inject(KeyTool) protected readonly keytool: KeyTool;
-
-    get id(): string {
-        return DelKeyDeleteTool.ID;
-    }
-
-    enable(): void {
-        this.keytool.register(this.deleteKeyListener);
-    }
-
-    disable(): void {
-        this.keytool.deregister(this.deleteKeyListener);
-    }
-}
-
-@injectable()
-export class DeleteKeyListener extends KeyListener {
-    override keyDown(element: SModelElement, event: KeyboardEvent): Action[] {
-        if (matchesKeystroke(event, 'Delete')) {
-            const deleteElementIds = Array.from(
-                element.root.index
-                    .all()
-                    .filter(e => isDeletable(e) && isSelectable(e) && e.selected)
-                    .filter(e => e.id !== e.root.id)
-                    .map(e => e.id)
-            );
-            if (deleteElementIds.length > 0) {
-                return [DeleteElementOperation.create(deleteElementIds)];
-            }
-        }
-        return [];
-    }
-}
-
-/**
- * Deletes selected elements when clicking on them.
- */
-@injectable()
-export class MouseDeleteTool implements GLSPTool {
-    static ID = 'glsp.delete-mouse';
-
-    isEditTool = true;
-
-    protected deleteToolMouseListener: DeleteToolMouseListener = new DeleteToolMouseListener();
-
-    @inject(TYPES.MouseTool) protected mouseTool: IMouseTool;
-    @inject(TYPES.IFeedbackActionDispatcher) protected readonly feedbackDispatcher: IFeedbackActionDispatcher;
-
-    get id(): string {
-        return MouseDeleteTool.ID;
-    }
-
-    enable(): void {
-        this.mouseTool.register(this.deleteToolMouseListener);
-        this.feedbackDispatcher.registerFeedback(this, [cursorFeedbackAction(CursorCSS.ELEMENT_DELETION)]);
-    }
-
-    disable(): void {
-        this.mouseTool.deregister(this.deleteToolMouseListener);
-        this.feedbackDispatcher.registerFeedback(this, [cursorFeedbackAction()]);
-    }
-}
-
-@injectable()
-export class DeleteToolMouseListener extends MouseListener {
-    override mouseUp(target: SModelElement, event: MouseEvent): Action[] {
-        const deletableParent = findParentByFeature(target, isDeletable);
-        if (deletableParent === undefined) {
-            return [];
-        }
-        const result: Action[] = [];
-        result.push(DeleteElementOperation.create([deletableParent.id]));
-        if (!isCtrlOrCmd(event)) {
-            result.push(EnableDefaultToolsAction.create());
-        }
-        return result;
-    }
-}

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

@@ -1,66 +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 } from 'sprotty';
-import { FocusStateChangedAction } from '../../base/actions/focus-change-action';
-import { TYPES } from '../../base/types';
-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 { 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) => {
-    // 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);
-});
-
-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,319 +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 { 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() protected 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)) {
-                result.push(
-                    ChangeRoutingPointsOperation.create([{ elementId: latestEdge.id, newRoutingPoints: latestEdge.routingPoints }])
-                );
-                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();
-    }
-}