@eclipse-glsp-examples/workflow-server 0.9.0-next.5ce3b9a.1

package/src/handler/create-workflow-node-operation-handler.ts

@@ -0,0 +1,56 @@
+/********************************************************************************
+ * Copyright (c) 2022 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
+ * 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 {
+    CreateNodeOperation,
+    CreateNodeOperationHandler,
+    GCompartment,
+    GModelElement,
+    GModelState,
+    Point
+} from '@eclipse-glsp/server-node';
+import { injectable, inject } from 'inversify';
+import { Category } from '../graph-extension';
+import { ModelTypes } from '../util/model-types';
+import { GridSnapper } from './grid-snapper';
+
+@injectable()
+export abstract class CreateWorkflowNodeOperationHandler extends CreateNodeOperationHandler {
+    @inject(GModelState)
+    protected modelState: GModelState;
+
+    getLocation(operation: CreateNodeOperation): Point | undefined {
+        return GridSnapper.snap(operation.location);
+    }
+
+    getContainer(operation: CreateNodeOperation): GModelElement | undefined {
+        const container = super.getContainer(operation);
+
+        if (container instanceof Category) {
+            const structComp = this.getCategoryCompartment(container);
+            if (structComp) {
+                return structComp;
+            }
+        }
+        return container;
+    }
+
+    getCategoryCompartment(category: Category): GCompartment | undefined {
+        return category.children
+            .filter(child => child instanceof GCompartment)
+            .map(child => child as GCompartment)
+            .find(comp => ModelTypes.STRUCTURE === comp.type);
+    }
+}

package/src/handler/grid-snapper.ts

@@ -0,0 +1,32 @@
+/********************************************************************************
+ * Copyright (c) 2022 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
+ * 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/server-node';
+
+export class GridSnapper {
+    public static GRID_X = 10.0;
+    public static GRID_Y = 10.0;
+
+    public static snap(originalPoint: Point | undefined): Point | undefined {
+        if (originalPoint) {
+            return {
+                x: Math.round(originalPoint.x / this.GRID_X) * this.GRID_X,
+                y: Math.round(originalPoint.y / this.GRID_Y) * this.GRID_Y
+            };
+        } else {
+            return undefined;
+        }
+    }
+}

package/src/index.ts

@@ -0,0 +1,19 @@
+/********************************************************************************
+ * Copyright (c) 2022 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
+ * 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 'reflect-metadata';
+import { launch } from './app';
+
+launch();

package/src/labeledit/workflow-label-edit-validator.ts

@@ -0,0 +1,39 @@
+/********************************************************************************
+ * Copyright (c) 2022 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
+ * 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 { GModelElement, GModelState, LabelEditValidator, ValidationStatus } from '@eclipse-glsp/server-node';
+import { inject, injectable } from 'inversify';
+import { TaskNode } from '../graph-extension';
+
+@injectable()
+export class WorkflowLabelEditValidator implements LabelEditValidator {
+    @inject(GModelState)
+    protected modelState: GModelState;
+
+    validate(label: string, element: GModelElement): ValidationStatus {
+        if (label.length < 1) {
+            return { severity: ValidationStatus.Severity.ERROR, message: 'Name must not be empty' };
+        }
+        const taskNodes = this.modelState.index.getAllByClass<TaskNode>(TaskNode);
+        const hasDuplicate = taskNodes
+            .filter(e => !(e.id === element.id))
+            .map(task => task.name)
+            .some(name => name === label);
+        if (hasDuplicate) {
+            return { severity: ValidationStatus.Severity.WARNING, message: 'Name should be unique' };
+        }
+        return { severity: ValidationStatus.Severity.OK };
+    }
+}

package/src/marker/workflow-model-validator.ts

@@ -0,0 +1,137 @@
+/********************************************************************************
+ * Copyright (c) 2022 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
+ * 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 { GModelElement, Marker, ModelValidator, GModelState, MarkerKind, GCompartment, GLabel } from '@eclipse-glsp/server-node';
+import { inject, injectable } from 'inversify';
+import { ActivityNode, TaskNode } from '../graph-extension';
+
+@injectable()
+export class WorkflowModelValidator implements ModelValidator {
+    @inject(GModelState)
+    protected readonly modelState: GModelState;
+
+    validate(elements: GModelElement[]): Marker[] {
+        const markers: Marker[] = [];
+        for (const element of elements) {
+            if (element instanceof TaskNode) {
+                markers.push(...this.validateTaskNode(element));
+            } else if (element instanceof ActivityNode) {
+                if (element.nodeType === 'decisionNode') {
+                    markers.push(...this.validateDecisionNode(element));
+                } else if (element.nodeType === 'mergeNode') {
+                    markers.push(...this.validateMergeNode(element));
+                }
+            }
+            if (element.children) {
+                markers.push(...this.validate(element.children));
+            }
+        }
+        return markers;
+    }
+
+    protected validateTaskNode(taskNode: TaskNode): Marker[] {
+        const markers: Marker[] = [];
+        const automated = this.validateTaskNode_isAutomated(taskNode);
+        if (automated) {
+            markers.push(automated);
+        }
+        const upperCase = this.validateTaskNode_labelStartsUpperCase(taskNode);
+        if (upperCase) {
+            markers.push(upperCase);
+        }
+        return markers;
+    }
+
+    protected validateTaskNode_isAutomated(taskNode: TaskNode): Marker | undefined {
+        if (taskNode.taskType === 'automated') {
+            return { kind: MarkerKind.INFO, description: 'This is an automated task', elementId: taskNode.id, label: 'Automated task' };
+        }
+        return undefined;
+    }
+
+    protected validateTaskNode_labelStartsUpperCase(taskNode: TaskNode): Marker | undefined {
+        const gCompartment = taskNode.children.find(child => child instanceof GCompartment);
+        if (gCompartment) {
+            const gLabels = gCompartment.children.filter(child => child instanceof GLabel).map(element => element as GLabel);
+            if (gLabels.length > 0 && gLabels[0].text.charAt(0) === gLabels[0].text.charAt(0).toLowerCase()) {
+                return {
+                    kind: MarkerKind.WARNING,
+                    description: 'Task node names should start with upper case letters',
+                    elementId: taskNode.id,
+                    label: 'Task node label in upper case'
+                };
+            }
+        }
+        return undefined;
+    }
+
+    protected validateDecisionNode(decisionNode: ActivityNode): Marker[] {
+        const markers: Marker[] = [];
+        const oneIncoming = this.validateDecisionNode_hasOneIncomingEdge(decisionNode);
+        if (oneIncoming) {
+            markers.push(oneIncoming);
+        }
+        return markers;
+    }
+
+    protected validateDecisionNode_hasOneIncomingEdge(decisionNode: ActivityNode): Marker | undefined {
+        const edges = this.modelState.index.getIncomingEdges(decisionNode);
+        if (edges.length > 1) {
+            return {
+                kind: MarkerKind.ERROR,
+                description: 'Decision node may only have one incoming edge.',
+                elementId: decisionNode.id,
+                label: 'Too many incoming edges'
+            };
+        } else if (edges.length === 0) {
+            return {
+                kind: MarkerKind.ERROR,
+                description: 'Decision node must have one incoming edge.',
+                elementId: decisionNode.id,
+                label: 'Missing incoming edge'
+            };
+        }
+        return undefined;
+    }
+
+    protected validateMergeNode(mergeNode: ActivityNode): Marker[] {
+        const markers: Marker[] = [];
+        const oneOutgoing = this.validateMergeNode_hasOneOutgoingEdge(mergeNode);
+        if (oneOutgoing) {
+            markers.push(oneOutgoing);
+        }
+        return markers;
+    }
+
+    protected validateMergeNode_hasOneOutgoingEdge(mergeNode: ActivityNode): Marker | undefined {
+        const edges = this.modelState.index.getOutgoingEdges(mergeNode);
+        if (edges.length > 1) {
+            return {
+                kind: MarkerKind.ERROR,
+                description: 'Merge node may only have one outgoing edge.',
+                elementId: mergeNode.id,
+                label: 'Too many outgoing edges'
+            };
+        } else if (edges.length === 0) {
+            return {
+                kind: MarkerKind.ERROR,
+                description: 'Merge node must have one outgoing edge.',
+                elementId: mergeNode.id,
+                label: 'Missing outgoing edge'
+            };
+        }
+        return undefined;
+    }
+}

package/src/model/workflow-navigation-target-resolver.ts

@@ -0,0 +1,40 @@
+/********************************************************************************
+ * Copyright (c) 2022 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
+ * 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 { NavigationTarget } from '@eclipse-glsp/protocol';
+import { GModelState } from '@eclipse-glsp/server-node';
+import { NavigationTargetResolution } from '@eclipse-glsp/server-node/lib/features/navigation/navigation-target-resolution';
+import { NavigationTargetResolver } from '@eclipse-glsp/server-node/lib/features/navigation/navigation-target-resolver';
+import { inject, injectable } from 'inversify';
+import { TaskNode } from '../graph-extension';
+
+@injectable()
+export class WorkflowNavigationTargetResolver extends NavigationTargetResolver {
+    @inject(GModelState)
+    protected readonly modelState: GModelState;
+
+    async resolve(navigationTarget: NavigationTarget): Promise<NavigationTargetResolution> {
+        if (navigationTarget.args && navigationTarget.args['name']) {
+            const name = navigationTarget.args['name'];
+            const taskNodes = this.modelState.index.getAllByClass<TaskNode>(TaskNode);
+            const element = taskNodes.find(node => name === node.name);
+            if (element) {
+                return new NavigationTargetResolution([element.id]);
+            }
+            return new NavigationTargetResolution([], this.createArgsWithWarning(`Couldn't find element with name ${name}`));
+        }
+        return NavigationTargetResolution.EMPTY;
+    }
+}

package/src/provider/abstract-next-or-previous-navigation-target-provider.ts

@@ -0,0 +1,53 @@
+/********************************************************************************
+ * Copyright (c) 2022 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
+ * 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 { Args, EditorContext, NavigationTarget } from '@eclipse-glsp/protocol';
+import { NavigationTargetProvider } from '@eclipse-glsp/server-node/lib/features/navigation/navigation-target-provider';
+import { inject, injectable } from 'inversify';
+import { GEdge, GModelState } from '@eclipse-glsp/server-node';
+import { TaskNode } from '../graph-extension';
+
+@injectable()
+export abstract class AbstractNextOrPreviousNavigationTargetProvider implements NavigationTargetProvider {
+    abstract targetTypeId: string;
+
+    @inject(GModelState)
+    protected readonly modelState: GModelState;
+
+    getTargets(editorContext: EditorContext): NavigationTarget[] {
+        const sourceUri = this.modelState.sourceUri;
+        const edges: GEdge[] = [];
+        editorContext.selectedElementIds
+            .map(id => this.modelState.index.get(id))
+            .filter(e => e instanceof TaskNode)
+            .map(e => e as TaskNode)
+            .map(taskNode => edges.push(...this.getEdges(taskNode)));
+        return edges.map(edge => this.getSourceOrTarget(edge)).map(id => this.createNavigationTarget(sourceUri, id));
+    }
+
+    protected createNavigationTarget(sourceURI: string | undefined, id: string): NavigationTarget {
+        return { uri: sourceURI ?? '', args: this.createElementIdMap(id) };
+    }
+
+    protected createElementIdMap(id: string): Args {
+        const map: Args = {};
+        map[NavigationTarget.ELEMENT_IDS] = id;
+        return map;
+    }
+
+    protected abstract getEdges(taskNode: TaskNode): GEdge[];
+
+    protected abstract getSourceOrTarget(edge: GEdge): string;
+}

package/src/provider/next-node-navigation-target-provider.ts

@@ -0,0 +1,31 @@
+/********************************************************************************
+ * Copyright (c) 2022 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
+ * 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 { GEdge } from '@eclipse-glsp/graph';
+import { TaskNode } from '../graph-extension';
+import { AbstractNextOrPreviousNavigationTargetProvider } from './abstract-next-or-previous-navigation-target-provider';
+import { injectable } from 'inversify';
+
+@injectable()
+export class NextNodeNavigationTargetProvider extends AbstractNextOrPreviousNavigationTargetProvider {
+    targetTypeId = 'next';
+    protected getEdges(taskNode: TaskNode): GEdge[] {
+        return this.modelState.index.getOutgoingEdges(taskNode);
+    }
+
+    protected getSourceOrTarget(edge: GEdge): string {
+        return edge.targetId;
+    }
+}

package/src/provider/node-documentation-navigation-target-provider.ts

@@ -0,0 +1,52 @@
+/********************************************************************************
+ * Copyright (c) 2022 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
+ * 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 { Args, EditorContext, NavigationTarget } from '@eclipse-glsp/protocol';
+import { GModelState } from '@eclipse-glsp/server-node';
+import { NavigationTargetProvider } from '@eclipse-glsp/server-node/lib/features/navigation/navigation-target-provider';
+import { inject, injectable } from 'inversify';
+import { TaskNode } from '../graph-extension';
+import { JsonOpenerOptions } from '@eclipse-glsp/server-node/lib/features/navigation/json-opener-options';
+
+@injectable()
+export class NodeDocumentationNavigationTargetProvider implements NavigationTargetProvider {
+    targetTypeId = 'documentation';
+
+    @inject(GModelState)
+    protected readonly modelState: GModelState;
+
+    getTargets(editorContext: EditorContext): NavigationTarget[] {
+        if (editorContext.selectedElementIds.length === 1) {
+            const taskNode = this.modelState.index.findByClass(editorContext.selectedElementIds[0], TaskNode);
+            if (!taskNode || !(taskNode.id === 'task0')) {
+                return [];
+            }
+
+            const sourceUri = this.modelState.sourceUri;
+            if (!sourceUri) {
+                return [];
+            }
+
+            const docUri = sourceUri.replace('.wf', '.md');
+            const args: Args = {};
+            args['jsonOpenerOptions'] = new JsonOpenerOptions({
+                start: { line: 2, character: 3 },
+                end: { line: 2, character: 7 }
+            }).toJson();
+            return [{ uri: docUri, args: args }];
+        }
+        return [];
+    }
+}

package/src/provider/previous-node-navigation-target-provider.ts

@@ -0,0 +1,31 @@
+/********************************************************************************
+ * Copyright (c) 2022 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
+ * 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 { GEdge } from '@eclipse-glsp/graph';
+import { TaskNode } from '../graph-extension';
+import { AbstractNextOrPreviousNavigationTargetProvider } from './abstract-next-or-previous-navigation-target-provider';
+import { injectable } from 'inversify';
+
+@injectable()
+export class PreviousNodeNavigationTargetProvider extends AbstractNextOrPreviousNavigationTargetProvider {
+    targetTypeId = 'previous';
+    protected getEdges(taskNode: TaskNode): GEdge[] {
+        return this.modelState.index.getIncomingEdges(taskNode);
+    }
+
+    protected getSourceOrTarget(edge: GEdge): string {
+        return edge.sourceId;
+    }
+}

package/src/provider/workflow-command-palette-action-provider.ts

@@ -0,0 +1,124 @@
+/********************************************************************************
+ * Copyright (c) 2022 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
+ * 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 {
+    Args,
+    CommandPaletteActionProvider,
+    CreateEdgeOperation,
+    CreateNodeOperation,
+    DefaultTypes,
+    DeleteElementOperation,
+    GModelElement,
+    GModelState,
+    GNode,
+    LabeledAction,
+    ORIGIN_POINT,
+    Point
+} from '@eclipse-glsp/server-node';
+import { inject, injectable } from 'inversify';
+import { TaskNode } from '../graph-extension';
+import { ModelTypes } from '../util/model-types';
+
+@injectable()
+export class WorkflowCommandPaletteActionProvider extends CommandPaletteActionProvider {
+    @inject(GModelState)
+    protected modelState: GModelState;
+
+    getPaletteActions(selectedElementIds: string[], selectedElements: GModelElement[], position: Point, args?: Args): LabeledAction[] {
+        const actions: LabeledAction[] = [];
+        if (this.modelState.isReadonly) {
+            return actions;
+        }
+        const index = this.modelState.index;
+        // Create actions
+        actions.push(
+            new LabeledAction(
+                'Create Automated Task',
+                [new CreateNodeOperation(ModelTypes.AUTOMATED_TASK, position ?? ORIGIN_POINT)],
+                'fa-plus-square'
+            ),
+            new LabeledAction(
+                'Create Manual Task',
+                [new CreateNodeOperation(ModelTypes.MANUAL_TASK, position ?? ORIGIN_POINT)],
+                'fa-plus-square'
+            ),
+            new LabeledAction(
+                'Create Merge Node',
+                [new CreateNodeOperation(ModelTypes.MERGE_NODE, position ?? ORIGIN_POINT)],
+                'fa-plus-square'
+            ),
+            new LabeledAction(
+                'Create Decision Node',
+                [new CreateNodeOperation(ModelTypes.DECISION_NODE, position ?? ORIGIN_POINT)],
+                'fa-plus-square'
+            ),
+            new LabeledAction('Create Category', [new CreateNodeOperation(ModelTypes.CATEGORY, position ?? ORIGIN_POINT)], 'fa-plus-square')
+        );
+        // Create edge action between two nodes
+        if (selectedElements.length === 1) {
+            const element = selectedElements[0];
+            if (element instanceof GNode) {
+                actions.push(...this.createEdgeActions(element, index.getAllByClass(TaskNode)));
+            }
+        } else if (selectedElements.length === 2) {
+            const source = selectedElements[0];
+            const target = selectedElements[1];
+            if (source instanceof TaskNode && target instanceof TaskNode) {
+                actions.push(
+                    this.createEdgeAction(`Create Edge from ${this.getLabel(source)} to ${this.getLabel(target)}`, source, target)
+                );
+                actions.push(
+                    this.createWeightedEdgeAction(
+                        `Create Weighted Edge from ${this.getLabel(source)} to ${this.getLabel(target)}`,
+                        source,
+                        target
+                    )
+                );
+            }
+        }
+        // Delete action
+        if (selectedElements.length === 1) {
+            actions.push(new LabeledAction('Delete', [new DeleteElementOperation(selectedElementIds)], 'fa-minus-square'));
+        } else if (selectedElements.length > 1) {
+            actions.push(new LabeledAction('Delete All', [new DeleteElementOperation(selectedElementIds)], 'fa-minus-square'));
+        }
+
+        return actions;
+    }
+
+    private createEdgeActions(source: GNode, targets: GNode[]): LabeledAction[] {
+        const actions: LabeledAction[] = [];
+        targets.forEach(node => actions.push(this.createEdgeAction(`Create Edge to ${this.getLabel(node)}`, source, node)));
+        targets.forEach(node =>
+            actions.push(this.createWeightedEdgeAction(`Create Weighted Edge to ${this.getLabel(node)}`, source, node))
+        );
+        return actions;
+    }
+
+    private createWeightedEdgeAction(label: string, source: GNode, node: GNode): LabeledAction {
+        return new LabeledAction(label, [new CreateEdgeOperation(ModelTypes.WEIGHTED_EDGE, source.id, node.id)], 'fa-plus-square');
+    }
+
+    private createEdgeAction(label: string, source: GNode, node: GNode): LabeledAction {
+        return new LabeledAction(label, [new CreateEdgeOperation(DefaultTypes.EDGE, source.id, node.id)], 'fa-plus-square');
+    }
+
+    private getLabel(node: GNode): string {
+        if (node instanceof TaskNode) {
+            return node.name;
+        }
+        return node.id;
+    }
+}

package/src/provider/workflow-context-menu-item-provider.ts

@@ -0,0 +1,38 @@
+/********************************************************************************
+ * Copyright (c) 2022 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
+ * 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 { Args, ContextMenuItemProvider, CreateNodeOperation, GModelState, MenuItem, Point } from '@eclipse-glsp/server-node';
+import { inject, injectable } from 'inversify';
+import { GridSnapper } from '../handler/grid-snapper';
+import { ModelTypes } from '../util/model-types';
+
+@injectable()
+export class WorkflowContextMenuItemProvider extends ContextMenuItemProvider {
+    @inject(GModelState)
+    protected modelState: GModelState;
+
+    getItems(selectedElementIds: string[], position: Point, args?: Args): MenuItem[] {
+        if (this.modelState.isReadonly) {
+            return [];
+        }
+        const snappedPosition = GridSnapper.snap(position);
+        const newAutTask = new MenuItem('newAutoTask', 'Automated Task', [
+            new CreateNodeOperation(ModelTypes.AUTOMATED_TASK, snappedPosition)
+        ]);
+        const newManTask = new MenuItem('newManualTask', 'Manual Task', [new CreateNodeOperation(ModelTypes.MANUAL_TASK, snappedPosition)]);
+        const newChildMenu = new MenuItem('new', 'New', undefined, [newAutTask, newManTask], 'add', '0_new');
+        return [newChildMenu];
+    }
+}