@eclipse-glsp/client 0.9.0-next.c5944e10

package/src/features/command-palette/di.config.ts

@@ -0,0 +1,34 @@
+/********************************************************************************
+ * 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 '../../../css/command-palette.css';
+
+import { ContainerModule } from 'inversify';
+import { CommandPalette, CommandPaletteActionProviderRegistry, TYPES } from 'sprotty';
+
+import { GLSP_TYPES } from '../../base/types';
+import { CommandPaletteTool } from './command-palette-tool';
+import { ServerCommandPaletteActionProvider } from './server-command-palette-provider';
+
+const glspCommandPaletteModule = new ContainerModule(bind => {
+    bind(CommandPalette).toSelf().inSingletonScope();
+    bind(TYPES.IUIExtension).toService(CommandPalette);
+    bind(CommandPaletteActionProviderRegistry).toSelf().inSingletonScope();
+    bind(TYPES.ICommandPaletteActionProviderRegistry).toService(CommandPaletteActionProviderRegistry);
+    bind(TYPES.ICommandPaletteActionProvider).to(ServerCommandPaletteActionProvider);
+    bind(GLSP_TYPES.IDefaultTool).to(CommandPaletteTool);
+});
+
+export default glspCommandPaletteModule;

package/src/features/command-palette/server-command-palette-provider.ts

@@ -0,0 +1,48 @@
+/********************************************************************************
+ * 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 { inject, injectable } from 'inversify';
+import { Action, ICommandPaletteActionProvider, LabeledAction, Point, SModelElement, TYPES } from 'sprotty';
+
+import { GLSPActionDispatcher } from '../../base/action-dispatcher';
+import { isSetContextActionsAction, RequestContextActions } from '../../base/actions/context-actions';
+import { EditorContextService } from '../../base/editor-context';
+
+export namespace ServerCommandPalette {
+    export const CONTEXT_ID = 'command-palette';
+    export const TEXT = 'text';
+    export const INDEX = 'index';
+}
+
+@injectable()
+export class ServerCommandPaletteActionProvider implements ICommandPaletteActionProvider {
+    @inject(TYPES.IActionDispatcher) protected actionDispatcher: GLSPActionDispatcher;
+    @inject(EditorContextService) protected editorContext: EditorContextService;
+
+    getActions(_root: Readonly<SModelElement>, text: string, _lastMousePosition?: Point, index?: number): Promise<LabeledAction[]> {
+        const requestAction = new RequestContextActions(ServerCommandPalette.CONTEXT_ID, this.editorContext.get({
+            [ServerCommandPalette.TEXT]: text,
+            [ServerCommandPalette.INDEX]: index ? index : 0
+        }));
+        return this.actionDispatcher.requestUntil(requestAction).then(response => this.getPaletteActionsFromResponse(response));
+    }
+
+    getPaletteActionsFromResponse(action: Action): LabeledAction[] {
+        if (isSetContextActionsAction(action)) {
+            return action.actions;
+        }
+        return [];
+    }
+}

package/src/features/context-menu/delete-element-context-menu.ts

@@ -0,0 +1,42 @@
+/********************************************************************************
+ * 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 } from 'inversify';
+import { IContextMenuItemProvider, MenuItem, Point, SModelRoot } from 'sprotty';
+
+import { EditorContextService, EditorContextServiceProvider } from '../../base/editor-context';
+import { DeleteElementOperation } from '../../base/operations/operation';
+import { GLSP_TYPES } from '../../base/types';
+
+@injectable()
+export class DeleteElementContextMenuItemProvider implements IContextMenuItemProvider {
+    @inject(GLSP_TYPES.IEditorContextServiceProvider) editorContextServiceProvider: EditorContextServiceProvider;
+
+    async getItems(_root: Readonly<SModelRoot>, _lastMousePosition?: Point): Promise<MenuItem[]> {
+        const editorContextService = await this.editorContextServiceProvider();
+        return [this.createDeleteMenuItem(editorContextService)];
+    }
+
+    protected createDeleteMenuItem(editorContextService: EditorContextService): MenuItem {
+        return {
+            id: 'delete',
+            label: 'Delete',
+            sortString: 'd',
+            group: 'edit',
+            actions: [new DeleteElementOperation(editorContextService.selectedElements.map(e => e.id))],
+            isEnabled: () => !editorContextService.isReadonly && editorContextService.selectedElements.length > 0
+        };
+    }
+}

package/src/features/context-menu/di.config.ts

@@ -0,0 +1,35 @@
+/********************************************************************************
+ * 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 { ContextMenuProviderRegistry, IContextMenuService, TYPES } from 'sprotty';
+
+import { SelectionServiceAwareContextMenuMouseListener } from './selection-service-aware-context-menu-mouse-listener';
+import { ServerContextMenuItemProvider } from './server-context-menu-provider';
+
+const glspContextMenuModule = new ContainerModule(bind => {
+    bind(TYPES.IContextMenuServiceProvider).toProvider<IContextMenuService>(ctx => () => new Promise<IContextMenuService>((resolve, reject) => {
+        if (ctx.container.isBound(TYPES.IContextMenuService)) {
+            resolve(ctx.container.get<IContextMenuService>(TYPES.IContextMenuService));
+        } else {
+            reject();
+        }
+    }));
+    bind(TYPES.MouseListener).to(SelectionServiceAwareContextMenuMouseListener);
+    bind(TYPES.IContextMenuProviderRegistry).to(ContextMenuProviderRegistry);
+    bind(TYPES.IContextMenuItemProvider).to(ServerContextMenuItemProvider);
+});
+
+export default glspContextMenuModule;

package/src/features/context-menu/selection-service-aware-context-menu-mouse-listener.ts

@@ -0,0 +1,50 @@
+/********************************************************************************
+ * 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 { inject, injectable, optional } from 'inversify';
+import {
+    Action,
+    ContextMenuProviderRegistry,
+    findParentByFeature,
+    IContextMenuServiceProvider,
+    isSelectable,
+    MouseListener,
+    SModelElement,
+    TYPES
+} from 'sprotty';
+
+import { GLSP_TYPES } from '../../base/types';
+import { SelectionService } from '../select/selection-service';
+
+@injectable()
+export class SelectionServiceAwareContextMenuMouseListener extends MouseListener {
+    @inject(TYPES.IContextMenuServiceProvider) @optional() protected readonly contextMenuService: IContextMenuServiceProvider;
+    @inject(TYPES.IContextMenuProviderRegistry) @optional() protected readonly menuProvider: ContextMenuProviderRegistry;
+    @inject(GLSP_TYPES.SelectionService) protected selectionService: SelectionService;
+
+    mouseDown(target: SModelElement, event: MouseEvent): (Action | Promise<Action>)[] {
+        if (event.button === 2 && this.contextMenuService && this.menuProvider) {
+            const mousePosition = { x: event.x, y: event.y };
+            const selectableTarget = findParentByFeature(target, isSelectable);
+            if (selectableTarget) {
+                selectableTarget.selected = true;
+                this.selectionService.updateSelection(target.root, [selectableTarget.id], []);
+            }
+            Promise.all([this.contextMenuService(), this.menuProvider.getItems(target.root, mousePosition)])
+                .then(([menuService, menuItems]) => menuService.show(menuItems, mousePosition));
+        }
+        return [];
+    }
+}

package/src/features/context-menu/server-context-menu-provider.ts

@@ -0,0 +1,46 @@
+/********************************************************************************
+ * 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 { inject, injectable } from 'inversify';
+import { Action, IContextMenuItemProvider, isSelected, LabeledAction, Point, SModelElement, TYPES } from 'sprotty';
+
+import { GLSPActionDispatcher } from '../../base/action-dispatcher';
+import { isSetContextActionsAction, RequestContextActions } from '../../base/actions/context-actions';
+import { EditorContextService } from '../../base/editor-context';
+
+export namespace ServerContextMenu {
+    export const CONTEXT_ID = 'context-menu';
+}
+
+@injectable()
+export class ServerContextMenuItemProvider implements IContextMenuItemProvider {
+
+    @inject(TYPES.IActionDispatcher) protected actionDispatcher: GLSPActionDispatcher;
+    @inject(EditorContextService) protected editorContext: EditorContextService;
+
+    getItems(root: Readonly<SModelElement>, lastMousePosition?: Point): Promise<LabeledAction[]> {
+        const selectedElementIds = Array.from(root.index.all().filter(isSelected).map(e => e.id));
+        const context = this.editorContext.getWithSelection(selectedElementIds);
+        const requestAction = new RequestContextActions(ServerContextMenu.CONTEXT_ID, context);
+        return this.actionDispatcher.requestUntil(requestAction).then(response => this.getContextActionsFromResponse(response));
+    }
+
+    getContextActionsFromResponse(action: Action): LabeledAction[] {
+        if (isSetContextActionsAction(action)) {
+            return action.actions;
+        }
+        return [];
+    }
+}

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

@@ -0,0 +1,60 @@
+/********************************************************************************
+ * 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 { generateRequestId, RequestAction, ResponseAction } from 'sprotty';
+
+import { EditorContext } from '../../base/editor-context';
+import { Operation } from '../../base/operations/operation';
+
+export class CutOperation implements Operation {
+    static readonly KIND = 'cut';
+
+    constructor(
+        public readonly editorContext: EditorContext,
+        public readonly kind: string = CutOperation.KIND) { }
+}
+
+export class PasteOperation implements Operation {
+    static readonly KIND = 'paste';
+
+    constructor(
+        public readonly clipboardData: ClipboardData,
+        public readonly editorContext: EditorContext,
+        public readonly kind: string = PasteOperation.KIND) { }
+}
+
+export class RequestClipboardDataAction implements RequestAction<SetClipboardDataAction> {
+    static readonly KIND = 'requestClipboardData';
+
+    constructor(
+        public readonly editorContext: EditorContext,
+        public readonly requestId: string = generateRequestId(),
+        public readonly kind: string = RequestClipboardDataAction.KIND) { }
+
+    static create(editorContext: EditorContext): RequestAction<SetClipboardDataAction> {
+        return new RequestClipboardDataAction(editorContext);
+    }
+}
+
+export interface ClipboardData { [format: string]: string }
+
+export class SetClipboardDataAction implements ResponseAction {
+    static readonly KIND = 'setClipboardData';
+
+    constructor(
+        public readonly clipboardData: ClipboardData,
+        public readonly responseId: string = '',
+        public readonly kind: string = SetClipboardDataAction.KIND) { }
+}

package/src/features/copy-paste/copy-paste-context-menu.ts

@@ -0,0 +1,138 @@
+/********************************************************************************
+ * 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 } from 'inversify';
+import {
+    Action,
+    IActionDispatcher,
+    IActionHandler,
+    IContextMenuItemProvider,
+    isSelected,
+    MenuItem,
+    Point,
+    SModelRoot,
+    TYPES
+} from 'sprotty/lib';
+
+import { GLSPServerStatusAction, ServerMessageAction } from '../../model-source/glsp-server-status';
+
+export class InvokeCopyAction implements Action {
+    static readonly KIND = 'invoke-copy';
+    constructor(public readonly kind = InvokeCopyAction.KIND) { }
+}
+
+export class InvokePasteAction implements Action {
+    static readonly KIND = 'invoke-paste';
+    constructor(public readonly kind = InvokePasteAction.KIND) { }
+}
+
+export class InvokeCutAction implements Action {
+    static readonly KIND = 'invoke-cut';
+    constructor(public readonly kind = InvokeCutAction.KIND) { }
+}
+
+@injectable()
+export class InvokeCopyPasteActionHandler implements IActionHandler {
+    @inject(TYPES.IActionDispatcher) protected dispatcher: IActionDispatcher;
+    handle(action: Action): void {
+        switch (action.kind) {
+            case InvokeCopyAction.KIND:
+                if (supportsCopy()) {
+                    document.execCommand('copy');
+                } else {
+                    this.notifyUserToUseShortcut('copy');
+                }
+                break;
+            case InvokePasteAction.KIND:
+                if (supportsPaste()) {
+                    document.execCommand('paste');
+                } else {
+                    this.notifyUserToUseShortcut('paste');
+                }
+                break;
+            case InvokeCutAction.KIND:
+                if (supportsCut()) {
+                    document.execCommand('cut');
+                } else {
+                    this.notifyUserToUseShortcut('cut');
+                }
+                break;
+        }
+    }
+
+    protected notifyUserToUseShortcut(operation: string): void {
+        const message = `Please use the browser's ${operation} command or shortcut.`;
+        const timeout = 10000;
+        const severity = 'WARNING';
+        this.dispatcher.dispatchAll([
+            { kind: GLSPServerStatusAction.KIND, severity, timeout, message } as GLSPServerStatusAction,
+            { kind: ServerMessageAction.KIND, severity, timeout, message } as ServerMessageAction
+        ]);
+    }
+}
+
+@injectable()
+export class CopyPasteContextMenuItemProvider implements IContextMenuItemProvider {
+    getItems(root: Readonly<SModelRoot>, _lastMousePosition?: Point): Promise<MenuItem[]> {
+        const hasSelectedElements = Array.from(root.index.all().filter(isSelected)).length > 0;
+        return Promise.resolve([
+            this.createCopyMenuItem(hasSelectedElements),
+            this.createCutMenuItem(hasSelectedElements),
+            this.createPasteMenuItem()
+        ]);
+    }
+
+    protected createPasteMenuItem(): MenuItem {
+        return {
+            id: 'paste', label: 'Paste', group: 'copy-paste',
+            actions: [new InvokePasteAction()], isEnabled: () => true
+        };
+    }
+
+    protected createCutMenuItem(hasSelectedElements: boolean): MenuItem {
+        return {
+            id: 'cut', label: 'Cut', group: 'copy-paste',
+            actions: [new InvokeCutAction()], isEnabled: () => hasSelectedElements
+        };
+    }
+
+    protected createCopyMenuItem(hasSelectedElements: boolean): MenuItem {
+        return {
+            id: 'copy', label: 'Copy', group: 'copy-paste',
+            actions: [new InvokeCopyAction()], isEnabled: () => hasSelectedElements
+        };
+    }
+}
+
+export function supportsCopy(): boolean {
+    return isNative() || document.queryCommandSupported('copy');
+}
+
+export function supportsCut(): boolean {
+    return isNative() || document.queryCommandSupported('cut');
+}
+
+export function supportsPaste(): boolean {
+    const isChrome = (userAgent().indexOf('Chrome') >= 0);
+    return isNative() || (!isChrome && document.queryCommandSupported('paste'));
+}
+
+export function isNative(): boolean {
+    return typeof (window as any).process !== 'undefined';
+}
+
+function userAgent(): string {
+    return typeof navigator !== 'undefined' ? navigator.userAgent : '';
+}

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

@@ -0,0 +1,152 @@
+/********************************************************************************
+ * 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 { inject, injectable } from 'inversify';
+import { TYPES, ViewerOptions } from 'sprotty';
+import { v4 as uuid } from 'uuid';
+
+import { GLSPActionDispatcher } from '../../base/action-dispatcher';
+import { EditorContextService } from '../../base/editor-context';
+import { GLSP_TYPES } from '../../base/types';
+import { ClipboardData, CutOperation, PasteOperation, RequestClipboardDataAction } from './copy-paste-actions';
+
+export interface ICopyPasteHandler {
+    handleCopy(event: ClipboardEvent): void;
+    handleCut(event: ClipboardEvent): void;
+    handlePaste(event: ClipboardEvent): void;
+}
+
+export interface IAsyncClipboardService {
+    clear(): void;
+    put(data: ClipboardData, id?: string): void;
+    get(id?: string): ClipboardData | undefined;
+}
+
+/**
+ * A local implementation of the async clipboard interface.
+ *
+ * This implementation just stores the clipboard data in memory, but not in the clipboard.
+ * This implementation can be used if you don't need to support cross-widget/browser/application
+ * data transfer and you would like to avoid to require the permission of the user for accessing the
+ * system clipboard asynchronously.
+ *
+ * In order to detect whether the user copied something else since we recorded the clipboard data
+ * we put a uuid into the system clipboard synchronously. If on paste this ID has changed or is not
+ * available anymore, we know that the user copied in another application or context, so we shouldn't
+ * paste what we have stored locally and just return undefined.
+ *
+ * Real async clipboard service implementations can just ignore the ID that is passed and rely on the
+ * system clipboard's content instead.
+ */
+@injectable()
+export class LocalClipboardService implements IAsyncClipboardService {
+    protected currentId?: string;
+    protected data?: ClipboardData;
+
+    clear(): void {
+        this.currentId = undefined;
+        this.data = undefined;
+    }
+
+    put(data: ClipboardData, id: string): void {
+        this.currentId = id;
+        this.data = data;
+    }
+
+    get(id?: string): ClipboardData | undefined {
+        if (id !== this.currentId) {
+            return undefined;
+        }
+        return this.data;
+    }
+}
+
+interface ClipboardId {
+    readonly clipboardId: string;
+}
+
+function toClipboardId(clipboardId: string): string {
+    return JSON.stringify({ clipboardId });
+}
+
+function isClipboardId(jsonData: any): jsonData is ClipboardId {
+    return jsonData !== undefined && 'clipboardId' in jsonData;
+}
+
+function getClipboardIdFromDataTransfer(dataTransfer: DataTransfer): string | undefined {
+    const jsonString = dataTransfer.getData(CLIPBOARD_DATA_FORMAT);
+    const jsonObject = jsonString ? JSON.parse(jsonString) : undefined;
+    return isClipboardId(jsonObject) ? jsonObject.clipboardId : undefined;
+}
+
+const CLIPBOARD_DATA_FORMAT = 'text/plain';
+
+@injectable()
+export class ServerCopyPasteHandler implements ICopyPasteHandler {
+
+    @inject(TYPES.IActionDispatcher) protected actionDispatcher: GLSPActionDispatcher;
+    @inject(TYPES.ViewerOptions) protected viewerOptions: ViewerOptions;
+    @inject(GLSP_TYPES.IAsyncClipboardService) protected clipboadService: IAsyncClipboardService;
+    @inject(EditorContextService) protected editorContext: EditorContextService;
+
+    handleCopy(event: ClipboardEvent): void {
+        if (event.clipboardData && this.shouldCopy(event)) {
+            const clipboardId = uuid();
+            event.clipboardData.setData(CLIPBOARD_DATA_FORMAT, toClipboardId(clipboardId));
+            this.actionDispatcher
+                .request(RequestClipboardDataAction.create(this.editorContext.get()))
+                .then(action => this.clipboadService.put(action.clipboardData, clipboardId));
+            event.preventDefault();
+        } else {
+            if (event.clipboardData) {
+                event.clipboardData.clearData();
+            }
+            this.clipboadService.clear();
+        }
+    }
+
+    handleCut(event: ClipboardEvent): void {
+        if (event.clipboardData && this.shouldCopy(event)) {
+            this.handleCopy(event);
+            this.actionDispatcher.dispatch(new CutOperation(this.editorContext.get()));
+            event.preventDefault();
+        }
+    }
+
+    handlePaste(event: ClipboardEvent): void {
+        if (event.clipboardData && this.shouldPaste(event)) {
+            const clipboardId = getClipboardIdFromDataTransfer(event.clipboardData);
+            const clipboardData = this.clipboadService.get(clipboardId);
+            if (clipboardData) {
+                this.actionDispatcher.dispatch(new PasteOperation(clipboardData, this.editorContext.get()));
+            }
+            event.preventDefault();
+        }
+    }
+
+    protected shouldCopy(_event: ClipboardEvent): boolean | null {
+        return this.editorContext.get().selectedElementIds.length > 0 && this.isDiagramActive();
+    }
+
+    protected shouldPaste(_event: ClipboardEvent): boolean | null {
+        return this.isDiagramActive();
+    }
+
+    private isDiagramActive(): boolean | null {
+        return document.activeElement instanceof SVGElement
+            && document.activeElement.parentElement
+            && document.activeElement.parentElement.id === this.viewerOptions.baseDiv;
+    }
+}

package/src/features/copy-paste/di.config.ts

@@ -0,0 +1,45 @@
+/********************************************************************************
+ * 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 { configureActionHandler } from 'sprotty/lib';
+
+import { GLSP_TYPES } from '../../base/types';
+import {
+    CopyPasteContextMenuItemProvider,
+    InvokeCopyAction,
+    InvokeCopyPasteActionHandler,
+    InvokeCutAction,
+    InvokePasteAction
+} from './copy-paste-context-menu';
+import { LocalClipboardService, ServerCopyPasteHandler } from './copy-paste-handler';
+
+export const glspServerCopyPasteModule = new ContainerModule((bind, _unbind, isBound) => {
+    bind(GLSP_TYPES.ICopyPasteHandler).to(ServerCopyPasteHandler);
+    bind(GLSP_TYPES.IAsyncClipboardService).to(LocalClipboardService).inSingletonScope();
+});
+
+/**
+ * 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 in Theia use the Theia-native
+ * `CopyPasteMenuContribution` in `glsp-theia-integration` instead.
+ */
+export const copyPasteContextMenuModule = new ContainerModule((bind, _unbind, isBound) => {
+    bind(GLSP_TYPES.IContextMenuProvider).to(CopyPasteContextMenuItemProvider).inSingletonScope();
+    bind(InvokeCopyPasteActionHandler).toSelf().inSingletonScope();
+    configureActionHandler({ bind, isBound }, InvokeCopyAction.KIND, InvokeCopyPasteActionHandler);
+    configureActionHandler({ bind, isBound }, InvokeCutAction.KIND, InvokeCopyPasteActionHandler);
+    configureActionHandler({ bind, isBound }, InvokePasteAction.KIND, InvokeCopyPasteActionHandler);
+});