@eclipse-glsp/client 0.9.0-next.c5944e10

package/src/base/operations/operation.ts

@@ -0,0 +1,178 @@
+/********************************************************************************
+ * 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 { Action, ApplyLabelEditAction, ElementAndBounds, isAction, LayoutAction, Point } from 'sprotty';
+
+import { Args } from '../args';
+
+/**
+ * Operations are actions that denote requests from the client to _modify_ the model. Model modifications are always performed by the server.
+ * After a successful modification, the server sends the updated model back to the client using the `UpdateModelAction`.
+ */
+export interface Operation extends Action { }
+
+export interface CreateOperation extends Operation {
+    elementTypeId: string;
+    args?: Args;
+}
+
+export function isCreateOperation(object?: any): object is CreateOperation {
+    return isAction(object) && 'elementTypeId' in object;
+}
+
+export class CreateNodeOperation implements CreateOperation {
+    static readonly KIND = 'createNode';
+
+    constructor(public readonly elementTypeId: string,
+        public location?: Point,
+        public containerId?: string,
+        public args?: Args,
+        public readonly kind: string = CreateNodeOperation.KIND) { }
+}
+
+export function isCreateNodeOperation(object?: any): object is CreateNodeOperation {
+    return isCreateOperation() && object.kind === CreateNodeOperation.KIND;
+}
+
+export class CreateEdgeOperation implements CreateOperation {
+    static readonly KIND = 'createEdge';
+
+    constructor(public readonly elementTypeId: string,
+        public sourceElementId: string,
+        public targetElementId: string,
+        public args?: Args,
+        public readonly kind: string = CreateEdgeOperation.KIND) { }
+}
+
+export function isCreateConnectionOperation(object?: any): object is CreateEdgeOperation {
+    return isCreateOperation() && object.kind === CreateEdgeOperation.KIND;
+}
+
+export class DeleteElementOperation implements Operation {
+    static readonly KIND = 'deleteElement';
+    constructor(readonly elementIds: string[], public readonly kind: string = DeleteElementOperation.KIND) { }
+}
+
+export function isDeleteElementOperation(object?: any): object is DeleteElementOperation {
+    return isAction(object) && object.kind === DeleteElementOperation.KIND && 'elementIds' in object;
+}
+
+export class ChangeBoundsOperation implements Operation {
+    static readonly KIND = 'changeBounds';
+    constructor(public newBounds: ElementAndBounds[], public readonly kind: string = ChangeBoundsOperation.KIND) { }
+}
+
+export function isChangeBoundsOperation(object?: any): object is ChangeBoundsOperation {
+    return isAction(object) && object.kind === ChangeBoundsOperation.KIND && 'newBounds' in object;
+}
+
+export class ChangeContainerOperation implements Operation {
+    static readonly KIND = 'changeContainer';
+    constructor(public readonly elementId: string,
+        public readonly targetContainerId: string,
+        public readonly location?: Point,
+        public readonly kind: string = ChangeContainerOperation.KIND) { }
+}
+
+export function isChangeContainerOperation(object?: any): object is ChangeContainerOperation {
+    return isAction(object) && object.kind === ChangeContainerOperation.KIND
+        && 'elementId' in object && typeof object['elementId'] === 'string'
+        && 'targetContainerId' in object && typeof object['targetContainerId'] === 'string';
+}
+
+export class ReconnectEdgeOperation implements Operation {
+    static readonly KIND = 'reconnectEdge';
+    constructor(public readonly edgeElementId: string,
+        public readonly sourceElementId: string,
+        public readonly targetElementId: string,
+        public readonly kind: string = ReconnectEdgeOperation.KIND) { }
+}
+
+export function isReconnectEdgeOperation(object?: any): object is ReconnectEdgeOperation {
+    return isAction(object) && object.kind === ReconnectEdgeOperation.KIND
+        && 'edgeElementId' in object && typeof object['edgeElementId'] === 'string'
+        && 'sourceElementId' in object && typeof object['sourceElementId'] === 'string'
+        && 'targetElementId' in object && typeof object['targetElementId'] === 'string';
+}
+
+export class ChangeRoutingPointsOperation implements Operation {
+    static readonly KIND = 'changeRoutingPoints';
+    constructor(public newRoutingPoints: ElementAndRoutingPoints[], public readonly kind: string = ChangeRoutingPointsOperation.KIND) { }
+}
+
+export function isChangeRoutingsPointsOperation(object?: any): object is ChangeRoutingPointsOperation {
+    return isAction(object) && object.kind === ChangeRoutingPointsOperation.KIND
+        && 'newRoutingPoints' in object && typeof object['newRoutingPoints'] === 'string';
+}
+
+export class CompoundOperation implements Operation {
+    static readonly KIND = 'compound';
+    constructor(public operationList: Operation[], public readonly kind: string = CompoundOperation.KIND) { }
+}
+
+export function isCompoundOperation(object?: any): object is CompoundOperation {
+    return isAction(object) && object.kind === CompoundOperation.KIND && 'operationList' in object;
+}
+
+/**
+ * The `ElementAndRoutingPoints` type is used to associate an edge with specific routing points.
+ */
+export interface ElementAndRoutingPoints {
+    /**
+     * The identifier of an element.
+     */
+    elementId: string;
+
+    /**
+     * The new list of routing points.
+     */
+    newRoutingPoints?: Point[];
+}
+
+export abstract class TriggerElementCreationAction implements Action {
+    constructor(public readonly elementTypeId: string, readonly args?: Args, public readonly kind: string = 'unknown') { }
+}
+
+export class TriggerNodeCreationAction extends TriggerElementCreationAction {
+    static readonly KIND = 'triggerNodeCreation';
+
+    constructor(public readonly elementTypeId: string, readonly args?: Args, public readonly kind = TriggerNodeCreationAction.KIND) {
+        super(elementTypeId, args, kind);
+    }
+}
+
+export class TriggerEdgeCreationAction extends TriggerElementCreationAction {
+    static readonly KIND = 'triggerEdgeCreation';
+
+    constructor(public readonly elementTypeId: string, readonly args?: Args, public readonly kind: string = TriggerEdgeCreationAction.KIND) {
+        super(elementTypeId, args, kind);
+    }
+}
+
+export function isTriggerElementTypeCreationAction(object?: any): object is TriggerElementCreationAction {
+    return isAction(object) && 'elementTypeId' in object;
+}
+
+export function isTriggerNodeCreationAction(object?: any): object is TriggerNodeCreationAction {
+    return isTriggerElementTypeCreationAction(object) && object.kind === TriggerNodeCreationAction.KIND;
+}
+
+export function isTriggerEdgeCreationAction(object?: any): object is TriggerEdgeCreationAction {
+    return isTriggerElementTypeCreationAction(object) && object.kind === TriggerEdgeCreationAction.KIND;
+}
+
+export class LayoutOperation extends LayoutAction implements Operation { }
+
+export class ApplyLabelEditOperation extends ApplyLabelEditAction implements Operation { }

package/src/base/selection-clearing-mouse-listener.ts

@@ -0,0 +1,43 @@
+/********************************************************************************
+ * 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 { injectable } from 'inversify';
+import { MouseListener, SModelElement } from 'sprotty';
+
+/**
+ * A mouse listener that clears the document selection on click
+ *
+ * Clicking on SVG elements doesn't update the document selection. In the context of diagramming
+ * with GLSP, this is unnatural, as the user would expect that clicking in the diagram (e.g. to
+ * select a diagram element) would clear any other selection state in the DOM. From a technical
+ * point of view, an active selection in the document after clicking into the diagram may also
+ * lead to bogus target elements in certain browser events, such as clipboard events, etc.
+ *
+ * This listener helps to overcome this problem by actively clearing any existing selection in
+ * the document, if the user clicks into the diagram.
+ */
+@injectable()
+export class SelectionClearingMouseListener extends MouseListener {
+    mouseDown(_target: SModelElement, event: MouseEvent): never[] {
+        const selection = document.getSelection();
+        // eslint-disable-next-line no-null/no-null
+        if (selection === null) {
+            return [];
+        }
+        selection.removeAllRanges();
+        selection.addRange(document.createRange());
+        return [];
+    }
+}

package/src/base/source-uri-aware.ts

@@ -0,0 +1,22 @@
+/********************************************************************************
+ * 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
+ ********************************************************************************/
+export abstract class SourceUriAware {
+    abstract getSourceURI(): string;
+}
+
+export function isSourceUriAware(obj: any): obj is SourceUriAware {
+    return obj !== undefined && typeof obj.getSourceURI === 'function';
+}

package/src/base/tool-manager/glsp-tool-manager.ts

@@ -0,0 +1,97 @@
+/********************************************************************************
+ * 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, multiInject, optional, postConstruct } from 'inversify';
+import { Tool, ToolManager } from 'sprotty';
+
+import { distinctAdd } from '../../utils/array-utils';
+import { EditMode } from '../actions/edit-mode-action';
+import { EditModeListener, EditorContextService, EditorContextServiceProvider } from '../editor-context';
+import { GLSP_TYPES } from '../types';
+
+export interface IGLSPToolManager extends ToolManager {
+    /* Disables all actives tools and activates only default tool with non-edit function*/
+    disableEditTools(): void;
+}
+
+@injectable()
+export class GLSPToolManager extends ToolManager implements IGLSPToolManager, EditModeListener {
+    protected editorContext?: EditorContextService;
+
+    @multiInject(GLSP_TYPES.ITool) @optional() tools: Tool[];
+    @multiInject(GLSP_TYPES.IDefaultTool) @optional() defaultTools: Tool[];
+    @inject(GLSP_TYPES.IEditorContextServiceProvider) contextServiceProvider: EditorContextServiceProvider;
+
+    @postConstruct()
+    protected initialize(): void {
+        this.registerTools(...this.tools);
+        this.registerDefaultTools(...this.defaultTools);
+        this.enableDefaultTools();
+        this.contextServiceProvider().then(editorContext => {
+            editorContext.register(this);
+            this.editorContext = editorContext;
+        });
+    }
+
+    registerDefaultTools(...tools: Tool[]): void {
+        for (const tool of tools) {
+            distinctAdd(this.defaultTools, tool);
+        }
+    }
+
+    registerTools(...tools: Tool[]): void {
+        for (const tool of tools) {
+            distinctAdd(this.tools, tool);
+        }
+    }
+
+    enable(toolIds: string[]): void {
+        this.disableActiveTools();
+        let tools = toolIds.map(id => this.tool(id));
+        if (this.editorContext && this.editorContext.isReadonly) {
+            tools = tools.filter(tool => tool && (!isGLSPTool(tool) || tool.isEditTool === false));
+        }
+        tools.forEach(tool => {
+            if (tool !== undefined) {
+                tool.enable();
+                this.actives.push(tool);
+            }
+        });
+    }
+
+    disableEditTools(): void {
+        this.disableActiveTools();
+        this.enable(this.defaultTools.filter(tool => !isGLSPTool(tool) || tool.isEditTool === false).map(tool => tool.id));
+    }
+
+    editModeChanged(oldValue: string, newValue: string): void {
+        if (oldValue === newValue) {
+            return;
+        }
+        if (newValue === EditMode.READONLY) {
+            this.disableEditTools();
+        } else if (newValue === EditMode.EDITABLE) {
+            this.enableDefaultTools();
+        }
+    }
+}
+
+export interface GLSPTool extends Tool {
+    isEditTool: boolean;
+}
+
+export function isGLSPTool(tool: Tool): tool is GLSPTool {
+    return 'isEditTool' in tool && typeof tool['isEditTool'] === 'boolean';
+}

package/src/base/types.ts

@@ -0,0 +1,37 @@
+/********************************************************************************
+ * 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
+ ********************************************************************************/
+export const GLSP_TYPES = {
+    IAsyncClipboardService: Symbol.for('IAsyncClipboardService'),
+    ICommandPaletteActionProviderRegistry: Symbol.for('ICommandPaletteActionProviderRegistry'),
+    IEditorContextServiceProvider: Symbol.for('IEditorContextProvider'),
+    IFeedbackActionDispatcher: Symbol.for('IFeedbackActionDispatcher'),
+    IToolFactory: Symbol.for('Factory<Tool>'),
+    ITypeHintProvider: Symbol.for('ITypeHintProvider'),
+    IMovementRestrictor: Symbol.for('IMovmementRestrictor'),
+    SelectionService: Symbol.for('SelectionService'),
+    SelectionListener: Symbol.for('SelectionListener'),
+    SModelRootListener: Symbol.for('SModelRootListener'),
+    MouseTool: Symbol.for('MouseTool'),
+    IContextMenuService: Symbol.for('IContextMenuService'),
+    IContextMenuServiceProvider: Symbol.for('IContextMenuServiceProvider'),
+    IContextMenuProviderRegistry: Symbol.for('IContextMenuProviderRegistry'),
+    IContextMenuProvider: Symbol.for('IContextMenuProvider'),
+    ICopyPasteHandler: Symbol.for('ICopyPasteHandler'),
+    IGLSPToolManager: Symbol.for('IGLSPToolManager'),
+    ITool: Symbol.for('ITool'),
+    IDefaultTool: Symbol.for('IDefaultTool'),
+    IEditModeListener: Symbol.for('IEditModeListener')
+};

package/src/base/view/view-registry.ts

@@ -0,0 +1,31 @@
+/********************************************************************************
+ * 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 { IView, ViewRegistry } from 'sprotty';
+
+@injectable()
+export class GLSPViewRegistry extends ViewRegistry {
+    register(key: string, instance: IView): void {
+        if (key === undefined) {
+            throw new Error('Key is undefined');
+        }
+        if (this.hasKey(key)) {
+            // do not throw error but log overwriting
+            console.log(`View instance for type '${key}' will be overwritten.`);
+        }
+        this.elements.set(key, instance);
+    }
+}

package/src/features/change-bounds/model.ts

@@ -0,0 +1,74 @@
+/********************************************************************************
+ * 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 {
+    BoundsAware,
+    Hoverable,
+    hoverFeedbackFeature,
+    isBoundsAware,
+    isMoveable,
+    isSelectable,
+    Locateable,
+    SChildElement,
+    Selectable,
+    SModelElement,
+    SParentElement
+} from 'sprotty';
+
+export const resizeFeature = Symbol('resizeFeature');
+
+export interface Resizable extends BoundsAware, Selectable {
+}
+
+export function isResizable(element: SModelElement): element is SParentElement & Resizable {
+    return isBoundsAware(element) && isSelectable(element) && element instanceof SParentElement && element.hasFeature(resizeFeature);
+}
+
+export enum ResizeHandleLocation {
+    TopLeft = 'top-left',
+    TopRight = 'top-right',
+    BottomLeft = 'bottom-left',
+    BottomRight = 'bottom-right'
+}
+
+export function isBoundsAwareMoveable(element: SModelElement): element is SModelElement & Locateable & BoundsAware {
+    return isMoveable(element) && isBoundsAware(element);
+}
+
+export class SResizeHandle extends SChildElement implements Hoverable {
+    static readonly TYPE = 'resize-handle';
+
+    constructor(public readonly location?: ResizeHandleLocation,
+        public readonly type: string = SResizeHandle.TYPE,
+        public readonly hoverFeedback: boolean = false) {
+        super();
+    }
+
+    hasFeature(feature: symbol): boolean {
+        return feature === hoverFeedbackFeature;
+    }
+}
+
+export function addResizeHandles(element: SParentElement): void {
+    removeResizeHandles(element);
+    element.add(new SResizeHandle(ResizeHandleLocation.TopLeft));
+    element.add(new SResizeHandle(ResizeHandleLocation.TopRight));
+    element.add(new SResizeHandle(ResizeHandleLocation.BottomLeft));
+    element.add(new SResizeHandle(ResizeHandleLocation.BottomRight));
+}
+
+export function removeResizeHandles(element: SParentElement): void {
+    element.removeAll(child => child instanceof SResizeHandle);
+}

package/src/features/change-bounds/movement-restrictor.ts

@@ -0,0 +1,89 @@
+/********************************************************************************
+ * 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 { injectable } from 'inversify';
+import { BoundsAware, Point, SModelElement, SNode, SParentElement } from 'sprotty';
+
+import { toAbsoluteBounds } from '../../utils/viewpoint-util';
+import { ModifyCSSFeedbackAction } from '../tool-feedback/css-feedback';
+import { isBoundsAwareMoveable, SResizeHandle } from './model';
+
+export interface IMovementRestrictor {
+    validate(newLocation: Point, element: SModelElement): boolean;
+    cssClasses?: string[];
+}
+
+export function createMovementRestrictionFeedback(element: SModelElement, movementRestrictor: IMovementRestrictor): ModifyCSSFeedbackAction {
+    const elements: SModelElement[] = [element];
+    if (element instanceof SParentElement) {
+        element.children.filter(child => child instanceof SResizeHandle).forEach(e => elements.push(e));
+    }
+    return new ModifyCSSFeedbackAction(elements, movementRestrictor.cssClasses);
+
+}
+
+export function removeMovementRestrictionFeedback(element: SModelElement, movementRestrictor: IMovementRestrictor): ModifyCSSFeedbackAction {
+    const elements: SModelElement[] = [element];
+    if (element instanceof SParentElement) {
+        element.children.filter(child => child instanceof SResizeHandle).forEach(e => elements.push(e));
+    }
+
+    return new ModifyCSSFeedbackAction(elements, undefined, movementRestrictor.cssClasses);
+}
+
+@injectable()
+export class NoOverlapMovmentRestrictor implements IMovementRestrictor {
+    cssClasses = ['movement-not-allowed'];
+
+    validate(newLocation: Point, element: SModelElement): boolean {
+        if (!isBoundsAwareMoveable(element)) {
+            return false;
+        }
+        // Create ghost element at the newLocation
+        const ghostElement = Object.create(element) as SModelElement & BoundsAware;
+        ghostElement.bounds = {
+            x: newLocation.x,
+            y: newLocation.y,
+            width: element.bounds.width,
+            height: element.bounds.height
+        };
+        ghostElement.type = 'Ghost';
+        ghostElement.id = element.id;
+        return !Array.from(element.root.index.all().filter(e => e.id !== ghostElement.id && e !== ghostElement.root && (e instanceof SNode))
+            .map(e => e as SModelElement & BoundsAware)).some(e => areOverlapping(e, ghostElement));
+    }
+}
+
+export function areOverlapping(element1: SModelElement & BoundsAware, element2: SModelElement & BoundsAware): boolean {
+    const b1 = toAbsoluteBounds(element1);
+    const b2 = toAbsoluteBounds(element2);
+    const r1TopLeft: Point = b1;
+    const r1BottomRight = { x: b1.x + b1.width, y: b1.y + b1.height };
+    const r2TopLeft: Point = b2;
+    const r2BottomRight = { x: b2.x + b2.width, y: b2.y + b2.height };
+
+    // If one rectangle is on left side of other
+    if (r1TopLeft.x > r2BottomRight.x || r2TopLeft.x > r1BottomRight.x) {
+        return false;
+    }
+
+    // If one rectangle is above other
+    if (r1BottomRight.y < r2TopLeft.y || r2BottomRight.y < r1TopLeft.y) {
+        return false;
+    }
+
+    return true;
+
+}

package/src/features/change-bounds/snap.ts

@@ -0,0 +1,35 @@
+/********************************************************************************
+ * 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 { injectable } from 'inversify';
+import { ISnapper, Point, SModelElement } from 'sprotty';
+
+@injectable()
+export class GridSnapper implements ISnapper {
+    get gridX(): number {
+        return 10;
+    }
+
+    get gridY(): number {
+        return 10;
+    }
+
+    snap(position: Point, element: SModelElement): Point {
+        return {
+            x: Math.round(position.x / this.gridX) * this.gridX,
+            y: Math.round(position.y / this.gridY) * this.gridY
+        };
+    }
+}

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

@@ -0,0 +1,46 @@
+/********************************************************************************
+ * 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, postConstruct } from 'inversify';
+import { CommandPaletteKeyListener, KeyListener, KeyTool, Tool } from 'sprotty';
+
+@injectable()
+export class CommandPaletteTool implements Tool {
+    static ID = 'glsp.command-palette-tool';
+
+    protected commandPaletteKeyListener: KeyListener;
+    @inject(KeyTool) protected keyTool: KeyTool;
+
+    @postConstruct()
+    protected postConstruct(): void {
+        this.commandPaletteKeyListener = this.createCommandPaleteKeyListener();
+    }
+
+    get id(): string {
+        return CommandPaletteTool.ID;
+    }
+
+    enable(): void {
+        this.keyTool.register(this.commandPaletteKeyListener);
+    }
+
+    disable(): void {
+        this.keyTool.deregister(this.commandPaletteKeyListener);
+    }
+
+    protected createCommandPaleteKeyListener(): KeyListener {
+        return new CommandPaletteKeyListener();
+    }
+}