@eclipse-glsp/client 1.1.0-next.e193103.187 → 1.1.0-next.ee71b2a.218

package/src/features/bounds/glsp-hidden-bounds-updater.ts

@@ -0,0 +1,88 @@
+/********************************************************************************
+ * 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, ComputedBoundsAction, Deferred, ElementAndRoutingPoints, RequestAction,
+    ResponseAction
+} from '@eclipse-glsp/protocol';
+import { inject, injectable, optional } from 'inversify';
+import { VNode } from 'snabbdom';
+import { EdgeRouterRegistry, HiddenBoundsUpdater, IActionDispatcher, SModelElement, SRoutableElement } from 'sprotty';
+import { calcElementAndRoute, isRoutable } from '../../utils/smodel-util';
+
+/**
+ * Grabs the bounds from hidden SVG DOM elements, applies layouts, collects routes and fires {@link ComputedBoundsAction}s.
+ *
+ * The actions will contain the bound, alignment, and routing points of elements.
+ */
+@injectable()
+export class GLSPHiddenBoundsUpdater extends HiddenBoundsUpdater {
+
+    @inject(EdgeRouterRegistry) @optional() protected readonly edgeRouterRegistry?: EdgeRouterRegistry;
+
+    protected element2route: ElementAndRoutingPoints[] = [];
+    protected edges: SRoutableElement[] = [];
+    protected nodes: VNode[] = [];
+
+    override decorate(vnode: VNode, element: SModelElement): VNode {
+        super.decorate(vnode, element);
+        if (isRoutable(element)) {
+            this.element2route.push(calcElementAndRoute(element, this.edgeRouterRegistry));
+        }
+        return vnode;
+    }
+
+    override postUpdate(cause?: Action): void {
+        const actions = this.captureActions(() => super.postUpdate(cause));
+        actions.filter(action => ComputedBoundsAction.is(action))
+            .forEach(action => this.actionDispatcher.dispatch(this.enhanceAction(action as ComputedBoundsAction)));
+        this.element2route = [];
+    }
+
+    protected captureActions(call: () => void): Action[] {
+        const capturingActionDispatcher = new CapturingActionDispatcher();
+        const actualActionDispatcher = this.actionDispatcher;
+        this.actionDispatcher = capturingActionDispatcher;
+        try {
+            call();
+            return capturingActionDispatcher.actions;
+        } finally {
+            this.actionDispatcher = actualActionDispatcher;
+        }
+    }
+
+    protected enhanceAction(action: ComputedBoundsAction): ComputedBoundsAction {
+        action.routes = this.element2route.length === 0 ? undefined : this.element2route;
+        return action;
+    }
+}
+
+class CapturingActionDispatcher implements IActionDispatcher {
+    readonly actions: Action[] = [];
+
+    async dispatch(action: Action): Promise<void> {
+        this.actions.push(action);
+    }
+
+    async dispatchAll(actions: Action[]): Promise<void> {
+        this.actions.push(...actions);
+    }
+
+    async request<Res extends ResponseAction>(action: RequestAction<Res>): Promise<Res> {
+        // ignore, not needed for our purposes
+        return new Deferred<Res>().promise;
+    }
+}

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

@@ -1,5 +1,5 @@
 /********************************************************************************
- * Copyright (c) 2020 EclipseSource and others.
+ * Copyright (c) 2019-2021 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

package/src/features/copy-paste/copy-paste-handler.ts

@@ -134,19 +134,15 @@ export class ServerCopyPasteHandler implements ICopyPasteHandler {
         }
     }
 
-    protected shouldCopy(_event: ClipboardEvent): boolean | null {
+    protected shouldCopy(_event: ClipboardEvent): boolean {
         return this.editorContext.get().selectedElementIds.length > 0 && this.isDiagramActive();
     }
 
-    protected shouldPaste(_event: ClipboardEvent): boolean | null {
+    protected shouldPaste(_event: ClipboardEvent): boolean {
         return this.isDiagramActive();
     }
 
-    private isDiagramActive(): boolean | null {
-        return (
-            document.activeElement instanceof SVGElement &&
-            document.activeElement.parentElement &&
-            document.activeElement.parentElement.id === this.viewerOptions.baseDiv
-        );
+    private isDiagramActive(): boolean {
+        return document.activeElement?.parentElement?.id === this.viewerOptions.baseDiv;
     }
 }

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

@@ -0,0 +1,28 @@
+/********************************************************************************
+ * 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 { ContainerModule } from 'inversify';
+import { configureCommand, ExportSvgCommand, ExportSvgKeyListener, ExportSvgPostprocessor, TYPES } from 'sprotty';
+import { GLSPSvgExporter } from './glsp-svg-exporter';
+
+const glspExportSvgModule = new ContainerModule((bind, _unbind, isBound) => {
+    bind(ExportSvgKeyListener).toSelf().inSingletonScope();
+    bind(TYPES.KeyListener).toService(ExportSvgKeyListener);
+    bind(TYPES.HiddenVNodePostprocessor).to(ExportSvgPostprocessor).inSingletonScope();
+    configureCommand({ bind, isBound }, ExportSvgCommand);
+    bind(TYPES.SvgExporter).to(GLSPSvgExporter).inSingletonScope();
+});
+
+export default glspExportSvgModule;

package/src/features/export/glsp-svg-exporter.ts

@@ -0,0 +1,50 @@
+/********************************************************************************
+ * 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 { RequestAction } from '@eclipse-glsp/protocol';
+import { injectable } from 'inversify';
+import { ExportSvgAction, SModelRoot, SvgExporter } from 'sprotty';
+import { v4 as uuid } from 'uuid';
+
+ @injectable()
+ export class GLSPSvgExporter extends SvgExporter {
+    override export(root: SModelRoot, _request?: RequestAction<ExportSvgAction>): void {
+        if (typeof document !== 'undefined') {
+            const svgElement = this.findSvgElement();
+            if (svgElement) {
+                // createSvg requires the svg to have a non-empty id, so we generate one if necessary
+                const originalId = svgElement.id;
+                try {
+                    svgElement.id = originalId || uuid();
+                    // provide generated svg code with respective sizing for proper viewing in browser and remove undesired border
+                    const bounds = this.getBounds(root);
+                    const svg = this.createSvg(svgElement, root)
+                        .replace('style="',
+                            `style="width: ${bounds.width}px !important;height: ${bounds.height}px !important;border: none !important;`);
+                    // do not give request/response id here as otherwise the action is treated as an unrequested response
+                    this.actionDispatcher.dispatch(ExportSvgAction.create(svg, ''));
+                } finally {
+                    svgElement.id = originalId;
+                }
+            }
+        }
+    }
+
+    protected findSvgElement(): SVGSVGElement | null {
+        const div = document.getElementById(this.options.hiddenDiv);
+        // search for first svg element as hierarchy within Sprotty might change
+        return div && div.querySelector('svg');
+    }
+ }

package/src/features/hover/hover.ts

@@ -23,7 +23,8 @@ import {
     SModelRootSchema
 } from '@eclipse-glsp/protocol';
 import { injectable } from 'inversify';
-import { EMPTY_ROOT, HoverFeedbackAction, HoverMouseListener, IActionHandler, ICommand, SModelElement } from 'sprotty';
+import { EMPTY_ROOT, HoverMouseListener, IActionHandler, ICommand, SModelElement } from 'sprotty';
+import { HoverFeedbackAction } from 'sprotty-protocol/lib/actions';
 import { FocusStateChangedAction } from '../../base/actions/focus-change-action';
 import { EnableDefaultToolsAction, EnableToolsAction } from '../../base/tool-manager/tool-actions';
 import { EdgeCreationTool } from '../tools/edge-creation-tool';

package/src/features/layout/layout-elements-action.ts

@@ -24,7 +24,8 @@ import {
     Writable
 } from '@eclipse-glsp/protocol';
 import { inject, injectable, optional } from 'inversify';
-import { ElementMove, IActionDispatcher, IActionHandler, ICommand, MoveAction, SModelElement } from 'sprotty';
+import { ElementMove, IActionDispatcher, IActionHandler, ICommand, SModelElement } from 'sprotty';
+import { MoveAction } from 'sprotty-protocol/lib/actions';
 import { TYPES } from '../../base/types';
 import { toValidElementAndBounds, toValidElementMove } from '../../utils/layout-utils';
 import { BoundsAwareModelElement, getElements } from '../../utils/smodel-util';

package/src/features/layout/tests/layouter-test-util.ts

@@ -1,5 +1,5 @@
 /********************************************************************************
- * Copyright (c) 2022 STMicroelectronics and others.
+ * Copyright (c) 2022-2023 STMicroelectronics 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
@@ -30,7 +30,7 @@ import {
     SParentElement,
     TYPES
 } from 'sprotty';
-import { createClientContainer } from '../../../base/container-modules';
+import { createDiagramContainer } from '../../../base/container-modules';
 import { GLSPGraph } from '../../../lib/model';
 import { StatefulLayouterExt } from '../layouter';
 
@@ -117,6 +117,6 @@ export function layout(
 export function setupLayoutRegistry(): LayoutRegistry {
     // Generic Test setup
     // create client container that registers all default modules including the layoutModule
-    const layoutContainer = createClientContainer();
+    const layoutContainer = createDiagramContainer();
     return layoutContainer.get<LayoutRegistry>(TYPES.LayoutRegistry);
 }

package/src/features/save/model.ts

@@ -1,5 +1,5 @@
 /********************************************************************************
- * Copyright (c) 2019 EclipseSource and others.
+ * Copyright (c) 2019-2021 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

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

@@ -15,7 +15,6 @@
  ********************************************************************************/
 import { Action, SelectAction } from '@eclipse-glsp/protocol';
 import {
-    BringToFrontAction,
     findParentByFeature,
     isCtrlOrCmd,
     isSelectable,
@@ -27,6 +26,7 @@ import {
     SRoutingHandle,
     SwitchEditModeAction
 } from 'sprotty';
+import { BringToFrontAction } from 'sprotty-protocol/lib/actions';
 import { toArray } from 'sprotty/lib/utils/iterable';
 import { DEFAULT_RANK, Ranked } from '../rank/model';
 
@@ -37,7 +37,7 @@ import { DEFAULT_RANK, Ranked } from '../rank/model';
 export class RankedSelectMouseListener extends SelectMouseListener implements Ranked {
     rank: number = DEFAULT_RANK - 1; /* we want to be executed before all default mouse listeners */
 
-    override mouseDown(target: SModelElement, event: MouseEvent): Action[] {
+    override mouseDown(target: SModelElement, event: MouseEvent): (Action | Promise<Action>)[] {
         const result: Action[] = [];
         if (this.buttonHandlerRegistry !== undefined && target instanceof SButton && target.enabled) {
             const buttonHandler = this.buttonHandlerRegistry.get(target.type);

package/src/features/source-model-watcher/di.config.ts

@@ -1,5 +1,5 @@
 /********************************************************************************
- * Copyright (c) 2020-2021 EclipseSource and others.
+ * 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

package/src/features/tool-feedback/change-bounds-tool-feedback.ts

@@ -25,12 +25,12 @@ import {
     isSelectable,
     isViewport,
     MouseListener,
-    MoveAction,
     SChildElement,
     SModelElement,
     SModelRoot,
     TYPES
 } from 'sprotty';
+import { MoveAction } from 'sprotty-protocol/lib/actions';
 import { forEachElement } from '../../utils/smodel-util';
 import { addResizeHandles, isResizable, removeResizeHandles, SResizeHandle } from '../change-bounds/model';
 import { createMovementRestrictionFeedback, removeMovementRestrictionFeedback } from '../change-bounds/movement-restrictor';

package/src/features/tool-feedback/creation-tool-feedback.ts

@@ -24,7 +24,6 @@ import {
     isBoundsAware,
     isConnectable,
     MouseListener,
-    MoveAction,
     PolylineEdgeRouter,
     SChildElement,
     SConnectableElement,
@@ -35,6 +34,7 @@ import {
     SRoutableElement,
     TYPES
 } from 'sprotty';
+import { MoveAction } from 'sprotty-protocol/lib/actions';
 import { BoundsAwareModelElement, isRoutable } from '../../utils/smodel-util';
 import { getAbsolutePosition, toAbsoluteBounds, toAbsolutePosition } from '../../utils/viewpoint-util';
 import { FeedbackCommand } from './model';

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

@@ -29,7 +29,6 @@ import {
     ISnapper,
     isSelected,
     MouseListener,
-    MoveAction,
     PolylineEdgeRouter,
     SConnectableElement,
     SModelElement,
@@ -39,6 +38,7 @@ import {
     SwitchEditModeCommand,
     TYPES
 } from 'sprotty';
+import { MoveAction } from 'sprotty-protocol/lib/actions';
 import { forEachElement, isRoutable, isRoutingHandle } from '../../utils/smodel-util';
 import { getAbsolutePosition, toAbsoluteBounds } from '../../utils/viewpoint-util';
 import { PointPositionUpdater } from '../change-bounds/snap';

package/src/features/tools/change-bounds-tool.ts

@@ -13,7 +13,7 @@
  *
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
-import {
+ import {
     Action,
     Bounds,
     ChangeBoundsOperation,
@@ -44,10 +44,10 @@ import { DragAwareMouseListener } from '../../base/drag-aware-mouse-listener';
 import { TYPES } from '../../base/types';
 import { isValidMove, isValidSize } from '../../utils/layout-utils';
 import {
+    calcElementAndRoutingPoints,
     forEachElement,
     isNonRoutableSelectedMovableBoundsAware,
-    toElementAndBounds,
-    toElementAndRoutingPoints
+    toElementAndBounds
 } from '../../utils/smodel-util';
 import { isBoundsAwareMoveable, isResizable, Resizable, ResizeHandleLocation, SResizeHandle } from '../change-bounds/model';
 import {
@@ -237,19 +237,22 @@ export class ChangeBoundsListener extends DragAwareMouseListener implements Sele
     }
 
     protected handleMoveRoutingPointsOnServer(target: SModelElement): Operation[] {
-        const result: Operation[] = [];
         const newRoutingPoints: ElementAndRoutingPoints[] = [];
-        forEachElement(target.index, isNonRoutableSelectedMovableBoundsAware, element => {
+        const routerRegistry = this.tool.edgeRouterRegistry;
+        if (routerRegistry) {
             //  If client routing is enabled -> delegate routingpoints of connected edges to server
-            if (this.tool.edgeRouterRegistry && element instanceof SConnectableElement) {
-                element.incomingEdges.map(toElementAndRoutingPoints).forEach(ear => newRoutingPoints.push(ear));
-                element.outgoingEdges.map(toElementAndRoutingPoints).forEach(ear => newRoutingPoints.push(ear));
-            }
-        });
-        if (newRoutingPoints.length > 0) {
-            result.push(ChangeRoutingPointsOperation.create(newRoutingPoints));
+            forEachElement(target.index, isNonRoutableSelectedMovableBoundsAware, element => {
+                if (element instanceof SConnectableElement) {
+                    element.incomingEdges.map(connectable => calcElementAndRoutingPoints(connectable, routerRegistry))
+                        .forEach(ear => newRoutingPoints.push(ear));
+                    element.outgoingEdges.map(connectable => calcElementAndRoutingPoints(connectable, routerRegistry))
+                        .forEach(ear => newRoutingPoints.push(ear));
+                }
+            });
         }
-        return result;
+        return newRoutingPoints.length > 0
+         ? [ChangeRoutingPointsOperation.create(newRoutingPoints)]
+         : [];
     }
 
     protected handleResize(activeResizeHandle: SResizeHandle): Action[] {

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

@@ -1,5 +1,5 @@
 /********************************************************************************
- * Copyright (c) 2019-2022 EclipseSource and others.
+ * Copyright (c) 2019-2023 EclipseSource and others.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0 which is available at
@@ -15,7 +15,7 @@
  ********************************************************************************/
 import { TriggerEdgeCreationAction, TriggerNodeCreationAction } from '@eclipse-glsp/protocol';
 import { ContainerModule, interfaces } from 'inversify';
-import { configureActionHandler, configureModelElement } from 'sprotty';
+import { configureActionHandler, configureModelElement, ManhattanEdgeRouter } from 'sprotty';
 import { FocusStateChangedAction } from '../../base/actions/focus-change-action';
 import { TYPES } from '../../base/types';
 import { MARQUEE } from '../tool-feedback/marquee-tool-feedback';
@@ -24,6 +24,7 @@ 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';
@@ -34,7 +35,7 @@ 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) => {
+export const toolsModule = new ContainerModule((bind, _unbind, isBound, rebind) => {
     // Register default tools
     bind(TYPES.IDefaultTool).to(ChangeBoundsTool);
     bind(TYPES.IDefaultTool).to(EdgeEditTool);
@@ -50,6 +51,9 @@ export const toolsModule = new ContainerModule((bind, _unbind, isBound) => {
     configureMarqueeTool({ bind, isBound });
     configureActionHandler({ bind, isBound }, TriggerNodeCreationAction.KIND, NodeCreationTool);
     configureActionHandler({ bind, isBound }, TriggerEdgeCreationAction.KIND, EdgeCreationTool);
+
+    bind(GSLPManhattanEdgeRouter).toSelf().inSingletonScope();
+    rebind(ManhattanEdgeRouter).toService(GSLPManhattanEdgeRouter);
 });
 
 export function configureMarqueeTool(context: { bind: interfaces.Bind; isBound: interfaces.IsBound }): void {

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

@@ -31,7 +31,7 @@ import {
 } from 'sprotty';
 import { DragAwareMouseListener } from '../../base/drag-aware-mouse-listener';
 import { TYPES } from '../../base/types';
-import { isRoutable, isRoutingHandle } from '../../utils/smodel-util';
+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';
@@ -53,7 +53,7 @@ export class EdgeEditTool extends BaseGLSPTool {
 
     @inject(TYPES.SelectionService) protected selectionService: SelectionService;
     @inject(AnchorComputerRegistry) protected anchorRegistry: AnchorComputerRegistry;
-    @inject(EdgeRouterRegistry) @optional() protected edgeRouterRegistry?: EdgeRouterRegistry;
+    @inject(EdgeRouterRegistry) @optional() readonly edgeRouterRegistry?: EdgeRouterRegistry;
     @inject(TYPES.ISnapper) @optional() readonly snapper?: ISnapper;
 
     protected feedbackEdgeSourceMovingListener: FeedbackEdgeSourceMovingMouseListener;
@@ -237,16 +237,15 @@ class EdgeEditListener extends DragAwareMouseListener implements SelectionListen
             // reroute actions
             const latestEdge = target.index.getById(this.edge.id);
             if (latestEdge && isRoutable(latestEdge)) {
-                result.push(
-                    ChangeRoutingPointsOperation.create([{ elementId: latestEdge.id, newRoutingPoints: latestEdge.routingPoints }])
-                );
+                const newRoutingPoints = calcElementAndRoutingPoints(latestEdge, this.tool.edgeRouterRegistry);
+                result.push(ChangeRoutingPointsOperation.create([newRoutingPoints]));
                 this.routingHandle = undefined;
             }
         }
         return result;
     }
 
-    override mouseOver(target: SModelElement, event: MouseEvent): Action[] {
+    override mouseOver(target: SModelElement, _event: MouseEvent): Action[] {
         if (this.edge && this.isReconnecting()) {
             const currentTarget = findParentByFeature(target, isConnectable);
             if (!this.newConnectable || currentTarget !== this.newConnectable) {

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

@@ -0,0 +1,57 @@
+/********************************************************************************
+ * 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;
+            }
+        });
+    }
+}

package/src/features/validation/issue-marker.ts

@@ -1,5 +1,5 @@
 /********************************************************************************
- * Copyright (c) 2019-2021 EclipseSource and others.
+ * 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

package/src/lib/model.ts

@@ -1,5 +1,5 @@
 /********************************************************************************
- * Copyright (c) 2019-2022 EclipseSource and others.
+ * Copyright (c) 2019-2023 EclipseSource and others.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0 which is available at
@@ -13,8 +13,8 @@
  *
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
-import { SModelElementSchema } from '@eclipse-glsp/protocol';
-import { exportFeature, SGraph, SModelElement, viewportFeature } from 'sprotty';
+import { Bounds, isBounds, Point, SModelElementSchema } from '@eclipse-glsp/protocol';
+import { exportFeature, getRouteBounds, SEdge, SGraph, SModelElement, viewportFeature } from 'sprotty';
 import { Containable, containerFeature } from '../features/hints/model';
 import { Saveable, saveFeature } from '../features/save/model';
 
@@ -25,3 +25,35 @@ export class GLSPGraph extends SGraph implements Saveable, Containable {
         return true;
     }
 }
+
+export class GEdge extends SEdge {
+    override localToParent(point: Point | Bounds): Bounds {
+        const bounds = getRouteBounds(this.routingPoints);
+        const result = {
+            x: point.x + bounds.x,
+            y: point.y + bounds.y,
+            width: -1,
+            height: -1
+        };
+        if (isBounds(point)) {
+            result.width = point.width;
+            result.height = point.height;
+        }
+        return result;
+    }
+
+    override parentToLocal(point: Point | Bounds): Bounds {
+        const bounds = getRouteBounds(this.routingPoints);
+        const result = {
+            x: point.x - bounds.x,
+            y: point.y - bounds.y,
+            width: -1,
+            height: -1
+        };
+        if (isBounds(point)) {
+            result.width = point.width;
+            result.height = point.height;
+        }
+        return result;
+    }
+}