@eclipse-glsp/client 0.9.0-next.c5944e10

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

@@ -0,0 +1,244 @@
+/********************************************************************************
+ * Copyright (c) 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
+ * 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 { inject, injectable } from 'inversify';
+import {
+    Action,
+    BoundsAware,
+    EnableDefaultToolsAction,
+    isSelectable,
+    isSelected,
+    KeyListener,
+    Point,
+    SEdge,
+    SelectAction,
+    SModelElement,
+    SNode,
+    TYPES
+} from 'sprotty';
+import { DOMHelper } from 'sprotty/lib/base/views/dom-helper';
+
+import { DragAwareMouseListener } from '../../base/drag-aware-mouse-listener';
+import { getAbsolutePosition, toAbsoluteBounds } from '../../utils/viewpoint-util';
+import { CursorCSS, cursorFeedbackAction } from '../tool-feedback/css-feedback';
+import { DrawMarqueeAction, RemoveMarqueeAction } from '../tool-feedback/marquee-tool-feedback';
+import { BaseGLSPTool } from '../tools/base-glsp-tool';
+
+@injectable()
+export class MarqueeMouseTool extends BaseGLSPTool {
+    static ID = 'glsp.marquee-mouse-tool';
+
+    @inject(TYPES.DOMHelper) protected domHelper: DOMHelper;
+
+    protected marqueeMouseListener: MarqueeMouseListener;
+    protected shiftKeyListener: ShiftKeyListener = new ShiftKeyListener();
+
+    get id(): string {
+        return MarqueeMouseTool.ID;
+    }
+
+    enable(): void {
+        this.marqueeMouseListener = new MarqueeMouseListener(this.domHelper);
+        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()]);
+    }
+}
+
+@injectable()
+export class MarqueeMouseListener extends DragAwareMouseListener {
+
+    protected startPoint: Point;
+
+    protected currentPoint: Point;
+
+    protected domHelper: DOMHelper;
+
+    protected previouslySelected: string[];
+
+    protected isActive = false;
+
+    constructor(domHelper: DOMHelper) {
+        super();
+        this.domHelper = domHelper;
+    }
+
+    mouseDown(target: SModelElement, event: MouseEvent): Action[] {
+        this.isActive = true;
+        this.startPoint = { x: getAbsolutePosition(target, event).x, y: getAbsolutePosition(target, event).y };
+        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 [];
+    }
+
+    mouseMove(target: SModelElement, event: MouseEvent): Action[] {
+        this.currentPoint = { x: getAbsolutePosition(target, event).x, y: getAbsolutePosition(target, event).y };
+        if (this.isActive) {
+            const nodeIdsSelected = Array.from(target.root.index.all()
+                .map(e => e as SModelElement & BoundsAware)
+                .filter(e => isSelectable(e))
+                .filter(e => e instanceof SNode)
+                .filter(e => this.isNodeMarked(e)).map(e => e.id));
+            const edgeIdsSelected = this.getMarkedEdges(target.root);
+            const selected = nodeIdsSelected.concat(edgeIdsSelected);
+            return [
+                new SelectAction([], Array.from(target.root.index.all().map(e => e.id))),
+                new SelectAction(selected.concat(this.previouslySelected), []),
+                new DrawMarqueeAction(this.startPoint,
+                    { x: getAbsolutePosition(target, event).x, y: getAbsolutePosition(target, event).y })
+            ];
+        }
+        return [];
+    }
+
+    mouseUp(target: SModelElement, event: MouseEvent): Action[] {
+        this.isActive = false;
+        if (event.shiftKey) {
+            return [new RemoveMarqueeAction()];
+        }
+        return [new RemoveMarqueeAction(), new EnableDefaultToolsAction()];
+    }
+
+    getMarkedEdges(root: SModelElement): string[] {
+        const elements = Array.from(document.querySelectorAll('g'));
+        const edges = Array.from(root.index.all().filter(e => e instanceof SEdge).
+            filter(e => isSelectable(e)).map(e => e.id));
+        return elements.filter(e => edges.includes(this.domHelper.findSModelIdByDOMElement(e)))
+            .filter(e => this.isEdgeMarked(e)).map(e => this.domHelper.findSModelIdByDOMElement(e));
+    }
+
+    isEdgeMarked(element: SVGElement): boolean {
+        if (!element.getAttribute('transform')) {
+            if (element.children[0]) {
+                const path = element.children[0].getAttribute('d');
+                if (path) {
+                    const points = path.split(/M|L/);
+                    for (let i = 0; i < points.length - 1; i++) {
+                        const coord1 = points[i].split(',');
+                        const coord2 = points[i + 1].split(',');
+                        const point1 = { x: parseInt(coord1[0], 10), y: parseInt(coord1[1], 10) };
+                        const point2 = { x: parseInt(coord2[0], 10), y: parseInt(coord2[1], 10) };
+                        if (this.isLineMarked(point1, point2)) {
+                            return true;
+                        }
+                    }
+                }
+            }
+        }
+        return false;
+    }
+
+    isLineMarked(point1: Point, point2: Point): boolean {
+        if (this.pointInRect(point1) || this.pointInRect(point2)) {
+            return true;
+        }
+        if (this.linesIntersect(point1, point2, this.startPoint, { x: this.startPoint.x, y: this.currentPoint.y })) {
+            return true;
+        }
+        if (this.linesIntersect(point1, point2, this.startPoint, { x: this.currentPoint.x, y: this.startPoint.y })) {
+            return true;
+        }
+        if (this.linesIntersect(point1, point2, { x: this.currentPoint.x, y: this.startPoint.y }, this.currentPoint)) {
+            return true;
+        }
+        if (this.linesIntersect(point1, point2, { x: this.startPoint.x, y: this.currentPoint.y }, this.currentPoint)) {
+            return true;
+        }
+        return false;
+    }
+
+    linesIntersect(p1: Point, p2: Point, p3: Point, p4: Point): boolean {
+        const tCount = ((p1.x - p3.x) * (p3.y - p4.y)) - ((p1.y - p3.y) * (p3.x - p4.x));
+        const tDenom = ((p1.x - p2.x) * (p3.y - p4.y)) - ((p1.y - p2.y) * (p3.x - p4.x));
+        const t = tCount / tDenom;
+        const uCount = ((p2.x - p1.x) * (p1.y - p3.y)) - ((p2.y - p1.y) * (p1.x - p3.x));
+        const uDenom = ((p1.x - p2.x) * (p3.y - p4.y)) - ((p1.y - p2.y) * (p3.x - p4.x));
+        const u = uCount / uDenom;
+        if (t >= 0.0 && t <= 1.0 && u >= 0.0 && u <= 1.0) {
+            return true;
+        }
+        return false;
+    }
+
+    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;
+    }
+
+    isNodeMarked(element: SModelElement & BoundsAware): boolean {
+        const horizontallyIn = this.startPoint.x < this.currentPoint.x ?
+            this.isElementBetweenXAxis(element, this.startPoint.x, this.currentPoint.x) :
+            this.isElementBetweenXAxis(element, this.currentPoint.x, this.startPoint.x);
+        const verticallyIn = this.startPoint.y < this.currentPoint.y ?
+            this.isElementBetweenYAxis(element, this.startPoint.y, this.currentPoint.y) :
+            this.isElementBetweenYAxis(element, this.currentPoint.y, this.startPoint.y);
+        if (horizontallyIn && verticallyIn) {
+            return true;
+        }
+        return false;
+    }
+
+    isElementBetweenXAxis(element: SModelElement & BoundsAware, marqueeLeft: number, marqueeRight: number): boolean {
+        if (this.isBetween(marqueeLeft, toAbsoluteBounds(element).x, toAbsoluteBounds(element).x + toAbsoluteBounds(element).width)
+            || this.isBetween(marqueeRight, toAbsoluteBounds(element).x, toAbsoluteBounds(element).x + toAbsoluteBounds(element).width)) {
+            return true;
+        }
+        const leftEdge = this.isBetween(toAbsoluteBounds(element).x, marqueeLeft, marqueeRight);
+        const rightEdge = this.isBetween(toAbsoluteBounds(element).x + toAbsoluteBounds(element).width, marqueeLeft, marqueeRight);
+        return leftEdge || rightEdge;
+    }
+
+    isElementBetweenYAxis(element: SModelElement & BoundsAware, marqueeTop: number, marqueeBottom: number): boolean {
+        if (this.isBetween(marqueeTop, toAbsoluteBounds(element).y, toAbsoluteBounds(element).y + toAbsoluteBounds(element).height)
+            || this.isBetween(marqueeBottom, toAbsoluteBounds(element).y, toAbsoluteBounds(element).y + toAbsoluteBounds(element).height)) {
+            return true;
+        }
+        const topEdge = this.isBetween(toAbsoluteBounds(element).y, marqueeTop, marqueeBottom);
+        const bottomEdge = this.isBetween(toAbsoluteBounds(element).y + toAbsoluteBounds(element).height, marqueeTop, marqueeBottom);
+        return topEdge || bottomEdge;
+    }
+
+    isBetween(x: number, lower: number, upper: number): boolean {
+        if (lower <= x && x <= upper) {
+            return true;
+        }
+        return false;
+    }
+
+}
+
+@injectable()
+export class ShiftKeyListener extends KeyListener {
+
+    keyUp(element: SModelElement, event: KeyboardEvent): Action[] {
+        if (event.shiftKey) {
+            return [];
+        }
+        return [new RemoveMarqueeAction(), new EnableDefaultToolsAction()];
+    }
+}

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

@@ -0,0 +1,52 @@
+/********************************************************************************
+ * Copyright (c) 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
+ * 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 { inject, injectable } from 'inversify';
+import { Action, 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 {
+
+    keyDown(element: SModelElement, event: KeyboardEvent): Action[] {
+        if (event.shiftKey) {
+            return [new EnableToolsAction([MarqueeMouseTool.ID])];
+        }
+        return [];
+    }
+}

package/src/features/tools/model.ts

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

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

@@ -0,0 +1,123 @@
+/********************************************************************************
+ * Copyright (c) 2020 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 { inject, injectable, optional } from 'inversify';
+import {
+    Action,
+    EnableDefaultToolsAction,
+    EnableToolsAction,
+    findParentByFeature,
+    IActionHandler,
+    isCtrlOrCmd,
+    ISnapper,
+    SModelElement,
+    SNode,
+    TYPES
+} from 'sprotty';
+
+import { DragAwareMouseListener } from '../../base/drag-aware-mouse-listener';
+import {
+    CreateNodeOperation,
+    isTriggerNodeCreationAction,
+    TriggerNodeCreationAction
+} from '../../base/operations/operation';
+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 (isTriggerNodeCreationAction(action)) {
+            this.triggerAction = action;
+            return new EnableToolsAction([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;
+    }
+
+    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(new CreateNodeOperation(this.elementTypeId, location, containerId, this.triggerAction.args));
+            if (!isCtrlOrCmd(event)) {
+                result.push(new EnableDefaultToolsAction());
+            }
+        }
+        return result;
+    }
+
+    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

@@ -0,0 +1,38 @@
+/********************************************************************************
+ * Copyright (c) 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
+ * 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 {
+    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/undo-redo/model.ts

@@ -0,0 +1,26 @@
+/********************************************************************************
+ * Copyright (c) 2019 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 { Operation } from '../../base/operations/operation';
+
+export class UndoOperation implements Operation {
+    static readonly KIND = 'glspUndo';
+    constructor(public readonly kind = UndoOperation.KIND) { }
+}
+
+export class RedoOperation implements Operation {
+    static readonly KIND = 'glspRedo';
+    constructor(public readonly kind = RedoOperation.KIND) { }
+}

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

@@ -0,0 +1,51 @@
+/********************************************************************************
+ * Copyright (c) 2019 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, TYPES } from 'sprotty';
+
+import { GLSP_TYPES } from '../../base/types';
+import {
+    LeftToRightTopToBottomComparator,
+    MarkerNavigator,
+    MarkerNavigatorContextMenuItemProvider,
+    MarkerNavigatorKeyListener,
+    NavigateToMarkerCommand,
+    SModelElementComparator
+} from './marker-navigator';
+import { ApplyMarkersCommand, DeleteMarkersCommand, SetMarkersCommand, ValidationFeedbackEmitter } from './validate';
+
+export const validationModule = new ContainerModule((bind, _unbind, isBound) => {
+    configureCommand({ bind, isBound }, SetMarkersCommand);
+    configureCommand({ bind, isBound }, ApplyMarkersCommand);
+    configureCommand({ bind, isBound }, DeleteMarkersCommand);
+    bind(ValidationFeedbackEmitter).toSelf().inSingletonScope();
+});
+
+export const markerNavigatorModule = new ContainerModule((bind, _unbind, isBound) => {
+    bind(SModelElementComparator).to(LeftToRightTopToBottomComparator).inSingletonScope();
+    bind(MarkerNavigator).toSelf().inSingletonScope();
+    configureCommand({ bind, isBound }, NavigateToMarkerCommand);
+});
+
+/**
+ * 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(GLSP_TYPES.IContextMenuProvider).to(MarkerNavigatorContextMenuItemProvider).inSingletonScope();
+    bind(TYPES.KeyListener).to(MarkerNavigatorKeyListener).inSingletonScope();
+});

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

@@ -0,0 +1,93 @@
+/********************************************************************************
+ * Copyright (c) 2019-2020 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 { SDecoration, SIssue, SIssueMarker, SParentElement } from 'sprotty';
+
+import { Marker, MarkerKind } from '../../utils/marker';
+
+export class GIssueMarker extends SIssueMarker {
+    constructor() {
+        super();
+        this.features = new Set<symbol>(SDecoration.DEFAULT_FEATURES);
+    }
+}
+
+/**
+ * Retrieves the `SIssueMarker` contained by the provided model element as
+ * direct child or a newly instantiated `SIssueMarker` if no child
+ * `SIssueMarker` exists.
+ * @param modelElement for which the `SIssueMarker` should be retrieved or created.
+ * @returns the child `SIssueMarker` or a new `SIssueMarker` if no such child exists.
+ */
+export function getOrCreateSIssueMarker(modelElement: SParentElement): SIssueMarker {
+    let issueMarker: SIssueMarker | undefined;
+
+    issueMarker = getSIssueMarker(modelElement);
+
+    if (issueMarker === undefined) {
+        issueMarker = new GIssueMarker();
+        issueMarker.type = 'marker';
+        issueMarker.issues = new Array<SIssue>();
+        modelElement.add(issueMarker);
+    }
+
+    return issueMarker;
+}
+
+/**
+ * Retrieves the `SIssueMarker` contained by the provided model element as
+ * direct child or `undefined` if such an `SIssueMarker` does not exist.
+ * @param modelElement for which the `SIssueMarker` should be retrieved.
+ * @returns the child `SIssueMarker` or `undefined` if no such child exists.
+ */
+export function getSIssueMarker(modelElement: SParentElement): SIssueMarker | undefined {
+    let issueMarker: SIssueMarker | undefined;
+
+    for (const child of modelElement.children) {
+        if (child instanceof SIssueMarker) {
+            issueMarker = child;
+        }
+    }
+
+    return issueMarker;
+}
+
+/**
+ * Creates an `SIssue` with `severity` and `message` set according to
+ * the `kind` and `description` of the provided `Marker`.
+ * @param marker `Marker` for that an `SIssue` should be created.
+ * @returns the created `SIssue`.
+ */
+export function createSIssue(marker: Marker): SIssue {
+    const issue: SIssue = new SIssue();
+    issue.message = marker.description;
+
+    switch (marker.kind) {
+        case MarkerKind.ERROR: {
+            issue.severity = 'error';
+            break;
+        }
+        case MarkerKind.INFO: {
+            issue.severity = 'info';
+            break;
+        }
+        case MarkerKind.WARNING: {
+            issue.severity = 'warning';
+            break;
+        }
+    }
+
+    return issue;
+}