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

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/marquee-behavior.ts

@@ -1,158 +0,0 @@
-/********************************************************************************
- * Copyright (c) 2021-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 { Bounds, Point } from '@eclipse-glsp/protocol';
-import { PointToPointLine } from 'sprotty';
-import { DrawMarqueeAction } from '../tool-feedback/marquee-tool-feedback';
-
-export interface IMarqueeBehavior {
-    readonly entireElement: boolean;
-    readonly entireEdge: boolean;
-}
-
-export class MarqueeUtil {
-    protected startPoint: Point;
-    protected currentPoint: Point;
-    protected marqueeBehavior: IMarqueeBehavior;
-
-    constructor(marqueeBehavior?: IMarqueeBehavior) {
-        if (marqueeBehavior) {
-            this.marqueeBehavior = marqueeBehavior;
-        } else {
-            this.marqueeBehavior = { entireElement: false, entireEdge: false };
-        }
-    }
-
-    updateStartPoint(position: Point): void {
-        this.startPoint = position;
-    }
-
-    updateCurrentPoint(position: Point): void {
-        this.currentPoint = position;
-    }
-
-    drawMarqueeAction(): DrawMarqueeAction {
-        return DrawMarqueeAction.create({ startPoint: this.startPoint, endPoint: this.currentPoint });
-    }
-
-    isEdgePathMarked(path: string | null): boolean {
-        if (!path) {
-            return false;
-        }
-        const points = path
-            .split(/M|L/)
-            .filter(p => p)
-            .map(p => {
-                const coord = p.split(',');
-                return { x: parseInt(coord[0], 10), y: parseInt(coord[1], 10) };
-            });
-        return this.isEdgeMarked(points);
-    }
-
-    isEdgeMarked(points: Point[]): boolean {
-        return this.marqueeBehavior.entireEdge ? this.isEntireEdgeMarked(points) : this.isPartOfEdgeMarked(points);
-    }
-
-    isNodeMarked(elementBounds: Bounds): boolean {
-        const horizontallyIn =
-            this.startPoint.x < this.currentPoint.x
-                ? this.isElementBetweenXAxis(elementBounds, this.startPoint.x, this.currentPoint.x)
-                : this.isElementBetweenXAxis(elementBounds, this.currentPoint.x, this.startPoint.x);
-        const verticallyIn =
-            this.startPoint.y < this.currentPoint.y
-                ? this.isElementBetweenYAxis(elementBounds, this.startPoint.y, this.currentPoint.y)
-                : this.isElementBetweenYAxis(elementBounds, this.currentPoint.y, this.startPoint.y);
-        return horizontallyIn && verticallyIn;
-    }
-
-    private isEntireEdgeMarked(points: Point[]): boolean {
-        for (let i = 0; i < points.length; i++) {
-            if (!this.pointInRect(points[i])) {
-                return false;
-            }
-        }
-        return true;
-    }
-
-    private isPartOfEdgeMarked(points: Point[]): boolean {
-        for (let i = 0; i < points.length - 1; i++) {
-            if (this.isLineMarked(points[i], points[i + 1])) {
-                return true;
-            }
-        }
-        return false;
-    }
-
-    private isLineMarked(point1: Point, point2: Point): boolean {
-        const line = new PointToPointLine(point1, point2);
-        return (
-            this.pointInRect(point1) ||
-            this.pointInRect(point2) ||
-            this.lineIntersect(line, this.startPoint, { x: this.startPoint.x, y: this.currentPoint.y }) ||
-            this.lineIntersect(line, this.startPoint, { x: this.currentPoint.x, y: this.startPoint.y }) ||
-            this.lineIntersect(line, { x: this.currentPoint.x, y: this.startPoint.y }, this.currentPoint) ||
-            this.lineIntersect(line, { x: this.startPoint.x, y: this.currentPoint.y }, this.currentPoint)
-        );
-    }
-
-    private lineIntersect(line: PointToPointLine, p1: Point, p2: Point): boolean {
-        return line.intersection(new PointToPointLine(p1, p2)) !== undefined;
-    }
-
-    private pointInRect(point: Point): boolean {
-        const boolX =
-            this.startPoint.x <= this.currentPoint.x
-                ? this.isBetween(point.x, this.startPoint.x, this.currentPoint.x)
-                : this.isBetween(point.x, this.currentPoint.x, this.startPoint.x);
-        const boolY =
-            this.startPoint.y <= this.currentPoint.y
-                ? this.isBetween(point.y, this.startPoint.y, this.currentPoint.y)
-                : this.isBetween(point.y, this.currentPoint.y, this.startPoint.y);
-        return boolX && boolY;
-    }
-
-    private isElementBetweenXAxis(elementBounds: Bounds, marqueeLeft: number, marqueeRight: number): boolean {
-        const leftEdge = this.isBetween(elementBounds.x, marqueeLeft, marqueeRight);
-        const rightEdge = this.isBetween(elementBounds.x + elementBounds.width, marqueeLeft, marqueeRight);
-        if (this.marqueeBehavior.entireElement) {
-            return leftEdge && rightEdge;
-        }
-        return (
-            leftEdge ||
-            rightEdge ||
-            this.isBetween(marqueeLeft, elementBounds.x, elementBounds.x + elementBounds.width) ||
-            this.isBetween(marqueeRight, elementBounds.x, elementBounds.x + elementBounds.width)
-        );
-    }
-
-    private isElementBetweenYAxis(elementBounds: Bounds, marqueeTop: number, marqueeBottom: number): boolean {
-        const topEdge = this.isBetween(elementBounds.y, marqueeTop, marqueeBottom);
-        const bottomEdge = this.isBetween(elementBounds.y + elementBounds.height, marqueeTop, marqueeBottom);
-        if (this.marqueeBehavior.entireElement) {
-            return topEdge && bottomEdge;
-        }
-        return (
-            topEdge ||
-            bottomEdge ||
-            this.isBetween(marqueeTop, elementBounds.y, elementBounds.y + elementBounds.height) ||
-            this.isBetween(marqueeBottom, elementBounds.y, elementBounds.y + elementBounds.height)
-        );
-    }
-
-    private isBetween(x: number, lower: number, upper: number): boolean {
-        return lower <= x && x <= upper;
-    }
-}

package/src/features/tools/marquee-mouse-tool.ts

@@ -1,152 +0,0 @@
-/********************************************************************************
- * Copyright (c) 2021-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, SelectAction } from '@eclipse-glsp/protocol';
-import { inject, injectable, optional } from 'inversify';
-import {
-    BoundsAware,
-    EnableDefaultToolsAction,
-    isSelectable,
-    isSelected,
-    KeyListener,
-    SEdge,
-    SModelElement,
-    SModelRoot,
-    SNode
-} from 'sprotty';
-import { DOMHelper } from 'sprotty/lib/base/views/dom-helper';
-import { DragAwareMouseListener } from '../../base/drag-aware-mouse-listener';
-import { TYPES } from '../../base/types';
-import { getAbsolutePosition, toAbsoluteBounds } from '../../utils/viewpoint-util';
-import { CursorCSS, cursorFeedbackAction } from '../tool-feedback/css-feedback';
-import { RemoveMarqueeAction } from '../tool-feedback/marquee-tool-feedback';
-import { BaseGLSPTool } from './base-glsp-tool';
-import { IMarqueeBehavior, MarqueeUtil } from './marquee-behavior';
-
-@injectable()
-export class MarqueeMouseTool extends BaseGLSPTool {
-    static ID = 'glsp.marquee-mouse-tool';
-
-    @inject(TYPES.DOMHelper) protected domHelper: DOMHelper;
-    @inject(TYPES.IMarqueeBehavior) @optional() protected marqueeBehavior: IMarqueeBehavior;
-
-    protected marqueeMouseListener: MarqueeMouseListener;
-    protected shiftKeyListener: ShiftKeyListener = new ShiftKeyListener();
-
-    get id(): string {
-        return MarqueeMouseTool.ID;
-    }
-
-    enable(): void {
-        this.marqueeMouseListener = new MarqueeMouseListener(this.domHelper, this.editorContext.modelRoot, this.marqueeBehavior);
-        this.mouseTool.register(this.marqueeMouseListener);
-        this.keyTool.register(this.shiftKeyListener);
-        this.dispatchFeedback([cursorFeedbackAction(CursorCSS.MARQUEE)]);
-    }
-
-    disable(): void {
-        this.mouseTool.deregister(this.marqueeMouseListener);
-        this.keyTool.deregister(this.shiftKeyListener);
-        this.deregisterFeedback([cursorFeedbackAction()]);
-    }
-}
-
-export class MarqueeMouseListener extends DragAwareMouseListener {
-    protected domHelper: DOMHelper;
-    protected marqueeUtil: MarqueeUtil;
-    protected nodes: (SModelElement & BoundsAware)[];
-    protected edges: SVGGElement[];
-    protected previouslySelected: string[];
-    protected isActive = false;
-
-    constructor(domHelper: DOMHelper, root: SModelRoot, marqueeBehavior: IMarqueeBehavior | undefined) {
-        super();
-        this.domHelper = domHelper;
-        this.marqueeUtil = new MarqueeUtil(marqueeBehavior);
-        this.nodes = Array.from(
-            root.index
-                .all()
-                .map(e => e as SModelElement & BoundsAware)
-                .filter(e => isSelectable(e))
-                .filter(e => e instanceof SNode)
-        );
-        const sEdges = Array.from(
-            root.index
-                .all()
-                .filter(e => e instanceof SEdge)
-                .filter(e => isSelectable(e))
-                .map(e => e.id)
-        );
-        this.edges = Array.from(document.querySelectorAll('g')).filter(e => sEdges.includes(this.domHelper.findSModelIdByDOMElement(e)));
-    }
-
-    override mouseDown(target: SModelElement, event: MouseEvent): Action[] {
-        this.isActive = true;
-        this.marqueeUtil.updateStartPoint(getAbsolutePosition(target, event));
-        if (event.ctrlKey) {
-            this.previouslySelected = Array.from(
-                target.root.index
-                    .all()
-                    .map(e => e as SModelElement & BoundsAware)
-                    .filter(e => isSelected(e))
-                    .map(e => e.id)
-            );
-        }
-        return [];
-    }
-
-    override mouseMove(target: SModelElement, event: MouseEvent): Action[] {
-        this.marqueeUtil.updateCurrentPoint(getAbsolutePosition(target, event));
-        if (this.isActive) {
-            const nodeIdsSelected = this.nodes.filter(e => this.marqueeUtil.isNodeMarked(toAbsoluteBounds(e))).map(e => e.id);
-            const edgeIdsSelected = this.edges.filter(e => this.isEdgeMarked(e)).map(e => this.domHelper.findSModelIdByDOMElement(e));
-            const selected = nodeIdsSelected.concat(edgeIdsSelected);
-            return [
-                SelectAction.create({ deselectedElementsIDs: Array.from(target.root.index.all().map(e => e.id)) }),
-                SelectAction.create({ selectedElementsIDs: selected.concat(this.previouslySelected) }),
-                this.marqueeUtil.drawMarqueeAction()
-            ];
-        }
-        return [];
-    }
-
-    override mouseUp(target: SModelElement, event: MouseEvent): Action[] {
-        this.isActive = false;
-        if (event.shiftKey) {
-            return [RemoveMarqueeAction.create()];
-        }
-        return [RemoveMarqueeAction.create(), EnableDefaultToolsAction.create()];
-    }
-
-    isEdgeMarked(element: SVGElement): boolean {
-        if (!element.getAttribute('transform')) {
-            if (element.children[0]) {
-                const path = element.children[0].getAttribute('d');
-                return this.marqueeUtil.isEdgePathMarked(path);
-            }
-        }
-        return false;
-    }
-}
-
-@injectable()
-export class ShiftKeyListener extends KeyListener {
-    override keyUp(element: SModelElement, event: KeyboardEvent): Action[] {
-        if (event.shiftKey) {
-            return [];
-        }
-        return [RemoveMarqueeAction.create(), EnableDefaultToolsAction.create()];
-    }
-}

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

@@ -1,51 +0,0 @@
-/********************************************************************************
- * Copyright (c) 2021-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 { inject, injectable } from 'inversify';
-import { EnableToolsAction, KeyListener, KeyTool, SModelElement } from 'sprotty';
-import { BaseGLSPTool } from '../tools/base-glsp-tool';
-import { MarqueeMouseTool } from './marquee-mouse-tool';
-
-@injectable()
-export class MarqueeTool extends BaseGLSPTool {
-    static ID = 'glsp.marquee-tool';
-
-    protected marqueeKeyListener: MarqueeKeyListener = new MarqueeKeyListener();
-
-    @inject(KeyTool) protected readonly keytool: KeyTool;
-
-    get id(): string {
-        return MarqueeTool.ID;
-    }
-
-    enable(): void {
-        this.keyTool.register(this.marqueeKeyListener);
-    }
-
-    disable(): void {
-        this.keyTool.deregister(this.marqueeKeyListener);
-    }
-}
-
-@injectable()
-export class MarqueeKeyListener extends KeyListener {
-    override keyDown(element: SModelElement, event: KeyboardEvent): Action[] {
-        if (event.shiftKey) {
-            return [EnableToolsAction.create([MarqueeMouseTool.ID])];
-        }
-        return [];
-    }
-}

package/src/features/tools/model.ts

@@ -1,23 +0,0 @@
-/********************************************************************************
- * Copyright (c) 2021-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 { Point } from '@eclipse-glsp/protocol';
-import { boundsFeature, RectangularNode } from 'sprotty';
-
-export class MarqueeNode extends RectangularNode {
-    static override readonly DEFAULT_FEATURES = [boundsFeature];
-    startPoint: Point;
-    endPoint: Point;
-}

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

@@ -1,116 +0,0 @@
-/********************************************************************************
- * Copyright (c) 2020-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, CreateNodeOperation, TriggerNodeCreationAction } from '@eclipse-glsp/protocol';
-import { inject, injectable, optional } from 'inversify';
-import {
-    EnableDefaultToolsAction,
-    EnableToolsAction,
-    findParentByFeature,
-    IActionHandler,
-    isCtrlOrCmd,
-    ISnapper,
-    SModelElement,
-    SNode,
-    TYPES
-} from 'sprotty';
-import { DragAwareMouseListener } from '../../base/drag-aware-mouse-listener';
-import { getAbsolutePosition } from '../../utils/viewpoint-util';
-import { Containable, isContainable } from '../hints/model';
-import { CursorCSS, cursorFeedbackAction } from '../tool-feedback/css-feedback';
-import { BaseGLSPTool } from './base-glsp-tool';
-
-@injectable()
-export class NodeCreationTool extends BaseGLSPTool implements IActionHandler {
-    static ID = 'tool_create_node';
-
-    @inject(TYPES.ISnapper) @optional() readonly snapper?: ISnapper;
-
-    protected creationToolMouseListener: NodeCreationToolMouseListener;
-    protected triggerAction: TriggerNodeCreationAction;
-
-    get id(): string {
-        return NodeCreationTool.ID;
-    }
-
-    enable(): void {
-        if (this.triggerAction === undefined) {
-            throw new TypeError(`Could not enable tool ${this.id}.The triggerAction cannot be undefined.`);
-        }
-        this.creationToolMouseListener = new NodeCreationToolMouseListener(this.triggerAction, this);
-        this.mouseTool.register(this.creationToolMouseListener);
-        this.dispatchFeedback([cursorFeedbackAction(CursorCSS.NODE_CREATION)]);
-    }
-
-    disable(): void {
-        this.mouseTool.deregister(this.creationToolMouseListener);
-        this.deregisterFeedback([cursorFeedbackAction()]);
-    }
-
-    handle(action: Action): Action | void {
-        if (TriggerNodeCreationAction.is(action)) {
-            this.triggerAction = action;
-            return EnableToolsAction.create([this.id]);
-        }
-    }
-}
-
-@injectable()
-export class NodeCreationToolMouseListener extends DragAwareMouseListener {
-    protected container?: SModelElement & Containable;
-
-    constructor(protected triggerAction: TriggerNodeCreationAction, protected tool: NodeCreationTool) {
-        super();
-    }
-
-    protected creationAllowed(elementTypeId: string): boolean | undefined {
-        return this.container && this.container.isContainableElement(elementTypeId);
-    }
-
-    get elementTypeId(): string {
-        return this.triggerAction.elementTypeId;
-    }
-
-    override nonDraggingMouseUp(target: SModelElement, event: MouseEvent): Action[] {
-        const result: Action[] = [];
-        if (this.creationAllowed(this.elementTypeId)) {
-            const containerId = this.container ? this.container.id : undefined;
-            let location = getAbsolutePosition(target, event);
-            if (this.tool.snapper) {
-                // Create a 0-bounds proxy element for snapping
-                const elementProxy = new SNode();
-                elementProxy.size = { width: 0, height: 0 };
-                location = this.tool.snapper.snap(location, elementProxy);
-            }
-            result.push(CreateNodeOperation.create(this.elementTypeId, { location, containerId, args: this.triggerAction.args }));
-            if (!isCtrlOrCmd(event)) {
-                result.push(EnableDefaultToolsAction.create());
-            }
-        }
-        return result;
-    }
-
-    override mouseOver(target: SModelElement, event: MouseEvent): Action[] {
-        const currentContainer = findParentByFeature(target, isContainable);
-        if (!this.container || currentContainer !== this.container) {
-            this.container = currentContainer;
-            const feedback = this.creationAllowed(this.elementTypeId)
-                ? cursorFeedbackAction(CursorCSS.NODE_CREATION)
-                : cursorFeedbackAction(CursorCSS.OPERATION_NOT_ALLOWED);
-            this.tool.dispatchFeedback([feedback]);
-        }
-        return [];
-    }
-}

package/src/features/tools/view.tsx

@@ -1,43 +0,0 @@
-/********************************************************************************
- * Copyright (c) 2021-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 { injectable } from 'inversify';
-import { VNode } from 'snabbdom';
-import { RectangularNodeView, RenderingContext, svg } from 'sprotty';
-import { MarqueeNode } from './model';
-
-// eslint-disable-next-line @typescript-eslint/no-unused-vars
-const JSX = { createElement: svg };
-
-@injectable()
-export class MarqueeView extends RectangularNodeView {
-    override render(node: MarqueeNode, context: RenderingContext): VNode {
-        const graph = (
-            <g>
-                <rect
-                    class-sprotty-node={true}
-                    class-marquee={true}
-                    x={node.startPoint.x - node.endPoint.x <= 0 ? node.startPoint.x : node.endPoint.x}
-                    y={node.startPoint.y - node.endPoint.y <= 0 ? node.startPoint.y : node.endPoint.y}
-                    rx={0}
-                    ry={0}
-                    width={Math.abs(node.startPoint.x - node.endPoint.x)}
-                    height={Math.abs(node.startPoint.y - node.endPoint.y)}
-                ></rect>
-            </g>
-        );
-        return graph;
-    }
-}

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

@@ -1,53 +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 { SetMarkersAction } from '@eclipse-glsp/protocol';
-import { ContainerModule } from 'inversify';
-import { configureActionHandler, configureCommand } from 'sprotty';
-import { TYPES } from '../../base/types';
-import {
-    LeftToRightTopToBottomComparator,
-    MarkerNavigator,
-    MarkerNavigatorContextMenuItemProvider,
-    MarkerNavigatorKeyListener,
-    NavigateToMarkerAction,
-    NavigateToMarkerActionHandler,
-    SModelElementComparator
-} from './marker-navigator';
-import { ApplyMarkersCommand, DeleteMarkersCommand, SetMarkersActionHandler, ValidationFeedbackEmitter } from './validate';
-
-export const validationModule = new ContainerModule((bind, _unbind, isBound) => {
-    const context = { bind, isBound };
-    configureActionHandler(context, SetMarkersAction.KIND, SetMarkersActionHandler);
-    configureCommand(context, ApplyMarkersCommand);
-    configureCommand(context, DeleteMarkersCommand);
-    bind(ValidationFeedbackEmitter).toSelf().inSingletonScope();
-});
-
-export const markerNavigatorModule = new ContainerModule((bind, _unbind, isBound) => {
-    bind(SModelElementComparator).to(LeftToRightTopToBottomComparator).inSingletonScope();
-    bind(MarkerNavigator).toSelf().inSingletonScope();
-    configureActionHandler({ bind, isBound }, NavigateToMarkerAction.KIND, NavigateToMarkerActionHandler);
-});
-
-/**
- * This module is not required if the diagram is deployed in Theia but only intended to be used
- * in a standalone deployment of GLSP. If the GLSP diagram is in Theia use the Theia-native
- * `registerMarkerNavigationCommands()` in `glsp-theia-integration` instead.
- */
-export const markerNavigatorContextMenuModule = new ContainerModule((bind, _unbind, isBound) => {
-    bind(TYPES.IContextMenuProvider).to(MarkerNavigatorContextMenuItemProvider).inSingletonScope();
-    bind(TYPES.KeyListener).to(MarkerNavigatorKeyListener).inSingletonScope();
-});

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

@@ -1,46 +0,0 @@
-/********************************************************************************
- * Copyright (c) 2021-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 { ContainerModule } from 'inversify';
-import {
-    CenterCommand,
-    CenterKeyboardListener,
-    configureActionHandler,
-    configureCommand,
-    EnableDefaultToolsAction,
-    EnableToolsAction,
-    FitToScreenCommand,
-    GetViewportCommand,
-    SetViewportCommand,
-    TYPES,
-    ZoomMouseListener
-} from 'sprotty';
-import { GLSPScrollMouseListener } from './glsp-scroll-mouse-listener';
-
-const glspViewportModule = new ContainerModule((bind, _unbind, isBound) => {
-    configureCommand({ bind, isBound }, CenterCommand);
-    configureCommand({ bind, isBound }, FitToScreenCommand);
-    configureCommand({ bind, isBound }, GetViewportCommand);
-    configureCommand({ bind, isBound }, SetViewportCommand);
-    bind(TYPES.KeyListener).to(CenterKeyboardListener);
-    bind(TYPES.MouseListener).to(ZoomMouseListener);
-    bind(GLSPScrollMouseListener).toSelf().inSingletonScope();
-    bind(TYPES.MouseListener).toService(GLSPScrollMouseListener);
-
-    configureActionHandler({ bind, isBound }, EnableToolsAction.KIND, GLSPScrollMouseListener);
-    configureActionHandler({ bind, isBound }, EnableDefaultToolsAction.KIND, GLSPScrollMouseListener);
-});
-
-export default glspViewportModule;