@eclipse-glsp/client 0.9.0-next.c5944e10

package/src/features/tool-feedback/edge-edit-tool-feedback.ts

@@ -0,0 +1,327 @@
+/********************************************************************************
+ * Copyright (c) 2019-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 { VNode } from 'snabbdom';
+import {
+    Action,
+    add,
+    AnchorComputerRegistry,
+    center,
+    CommandExecutionContext,
+    CommandReturn,
+    EdgeRouterRegistry,
+    ElementMove,
+    euclideanDistance,
+    findChildrenAtPosition,
+    findParentByFeature,
+    isBoundsAware,
+    isConnectable,
+    isSelected,
+    isViewport,
+    MouseListener,
+    MoveAction,
+    Point,
+    PolylineEdgeRouter,
+    SConnectableElement,
+    SModelElement,
+    SModelRoot,
+    SRoutingHandle,
+    SwitchEditModeAction,
+    SwitchEditModeCommand,
+    TYPES
+} from 'sprotty';
+
+import { isNotUndefined, isRoutable, isRoutingHandle } from '../../utils/smodel-util';
+import { getAbsolutePosition, toAbsoluteBounds } from '../../utils/viewpoint-util';
+import { addReconnectHandles, removeReconnectHandles } from '../reconnect/model';
+import {
+    FeedbackEdgeEnd,
+    feedbackEdgeEndId,
+    FeedbackEdgeEndMovingMouseListener,
+    feedbackEdgeId
+} from './creation-tool-feedback';
+import { FeedbackCommand } from './model';
+
+/**
+ * RECONNECT HANDLES FEEDBACK
+ */
+
+export class ShowEdgeReconnectHandlesFeedbackAction implements Action {
+    constructor(readonly elementId?: string, public readonly kind: string = ShowEdgeReconnectHandlesFeedbackCommand.KIND) { }
+}
+
+export class HideEdgeReconnectHandlesFeedbackAction implements Action {
+    constructor(public readonly kind: string = HideEdgeReconnectHandlesFeedbackCommand.KIND) { }
+}
+
+@injectable()
+export class ShowEdgeReconnectHandlesFeedbackCommand extends FeedbackCommand {
+    static readonly KIND = 'showReconnectHandlesFeedback';
+
+    constructor(@inject(TYPES.Action) protected action: ShowEdgeReconnectHandlesFeedbackAction) {
+        super();
+    }
+
+    execute(context: CommandExecutionContext): CommandReturn {
+        const index = context.root.index;
+        index.all().filter(isRoutable).forEach(removeReconnectHandles);
+
+        if (isNotUndefined(this.action.elementId)) {
+            const routableElement = index.getById(this.action.elementId);
+            if (isNotUndefined(routableElement) && isRoutable(routableElement)) {
+                addReconnectHandles(routableElement);
+            }
+        }
+        return context.root;
+    }
+}
+
+@injectable()
+export class HideEdgeReconnectHandlesFeedbackCommand extends FeedbackCommand {
+    static readonly KIND = 'hideReconnectHandlesFeedback';
+
+    constructor(@inject(TYPES.Action) protected action: HideEdgeReconnectHandlesFeedbackAction) {
+        super();
+    }
+
+    execute(context: CommandExecutionContext): CommandReturn {
+        const index = context.root.index;
+        index.all().filter(isRoutable).forEach(removeReconnectHandles);
+        return context.root;
+    }
+}
+/**
+ * ROUTING FEEDBACK
+ */
+
+export class SwitchRoutingModeAction extends SwitchEditModeAction {
+    constructor(public readonly elementsToActivate: string[] = [],
+        public readonly elementsToDeactivate: string[] = [],
+        public readonly kind: string = SwitchRoutingModeCommand.KIND) {
+        super(elementsToActivate, elementsToDeactivate);
+    }
+}
+
+@injectable()
+export class SwitchRoutingModeCommand extends SwitchEditModeCommand {
+    static KIND = 'switchRoutingMode';
+    constructor(@inject(TYPES.Action) action: SwitchRoutingModeAction) {
+        super(action);
+    }
+}
+
+/**
+ * SOURCE AND TARGET EDGE FEEDBACK
+ */
+
+export class DrawFeedbackEdgeSourceAction implements Action {
+    constructor(readonly elementTypeId: string, readonly targetId: string, public readonly kind: string = DrawFeedbackEdgeSourceCommand.KIND) { }
+}
+
+@injectable()
+export class DrawFeedbackEdgeSourceCommand extends FeedbackCommand {
+    static readonly KIND = 'drawFeedbackEdgeSource';
+
+    constructor(@inject(TYPES.Action) protected action: DrawFeedbackEdgeSourceAction) {
+        super();
+    }
+
+    execute(context: CommandExecutionContext): CommandReturn {
+        drawFeedbackEdgeSource(context, this.action.targetId, this.action.elementTypeId);
+        return context.root;
+    }
+}
+
+/**
+ * SOURCE AND TARGET MOUSE MOVE LISTENER
+ */
+
+export class FeedbackEdgeTargetMovingMouseListener extends FeedbackEdgeEndMovingMouseListener {
+    constructor(protected anchorRegistry: AnchorComputerRegistry) {
+        super(anchorRegistry);
+    }
+}
+
+export class FeedbackEdgeSourceMovingMouseListener extends MouseListener {
+    constructor(protected anchorRegistry: AnchorComputerRegistry) {
+        super();
+    }
+
+    mouseMove(target: SModelElement, event: MouseEvent): Action[] {
+        const root = target.root;
+        const edgeEnd = root.index.getById(feedbackEdgeEndId(root));
+        if (!(edgeEnd instanceof FeedbackEdgeEnd) || !edgeEnd.feedbackEdge) {
+            return [];
+        }
+
+        const edge = edgeEnd.feedbackEdge;
+        const position = getAbsolutePosition(edgeEnd, event);
+        const endAtMousePosition = findChildrenAtPosition(target.root, position)
+            .find(e => isConnectable(e) && e.canConnect(edge, 'source'));
+
+        if (endAtMousePosition instanceof SConnectableElement && edge.target && isBoundsAware(edge.target)) {
+            const anchor = this.computeAbsoluteAnchor(endAtMousePosition, center(edge.target.bounds));
+            if (euclideanDistance(anchor, edgeEnd.position) > 1) {
+                return [new MoveAction([{ elementId: edgeEnd.id, toPosition: anchor }], false)];
+            }
+        } else {
+            return [new MoveAction([{ elementId: edgeEnd.id, toPosition: position }], false)];
+        }
+
+        return [];
+    }
+
+    protected computeAbsoluteAnchor(element: SConnectableElement, referencePoint: Point, offset?: number): Point {
+        const anchorComputer = this.anchorRegistry.get(PolylineEdgeRouter.KIND, element.anchorKind);
+        let anchor = anchorComputer.getAnchor(element, referencePoint, offset);
+        // The anchor is computed in the local coordinate system of the element.
+        // If the element is a nested child element we have to add the absolute position of its parent to the anchor.
+        if (element.parent !== element.root) {
+            const parent = findParentByFeature(element.parent, isBoundsAware);
+            if (parent) {
+                const absoluteParentPosition = toAbsoluteBounds(parent);
+                anchor = add(absoluteParentPosition, anchor);
+            }
+        }
+        return anchor;
+    }
+}
+
+export class FeedbackEdgeRouteMovingMouseListener extends MouseListener {
+    protected hasDragged = false;
+    protected lastDragPosition: Point | undefined;
+
+    constructor(protected edgeRouterRegistry?: EdgeRouterRegistry) {
+        super();
+    }
+
+    mouseDown(target: SModelElement, event: MouseEvent): Action[] {
+        const result: Action[] = [];
+        if (event.button === 0) {
+            const routingHandle = findParentByFeature(target, isRoutingHandle);
+            if (routingHandle !== undefined) {
+                result.push(new SwitchRoutingModeAction([target.id], []));
+                this.lastDragPosition = { x: event.pageX, y: event.pageY };
+            } else {
+                this.lastDragPosition = undefined;
+            }
+            this.hasDragged = false;
+        }
+        return result;
+    }
+
+    mouseMove(target: SModelElement, event: MouseEvent): Action[] {
+        const result: Action[] = [];
+        if (event.buttons === 0) {
+            this.mouseUp(target, event);
+        } else if (this.lastDragPosition) {
+            const viewport = findParentByFeature(target, isViewport);
+            this.hasDragged = true;
+            const zoom = viewport ? viewport.zoom : 1;
+            const dx = (event.pageX - this.lastDragPosition.x) / zoom;
+            const dy = (event.pageY - this.lastDragPosition.y) / zoom;
+            const handleMoves: ElementMove[] = [];
+            target.root.index.all()
+                .filter(element => isSelected(element))
+                .forEach(element => {
+                    if (isRoutingHandle(element)) {
+                        const point = this.getHandlePosition(element);
+                        if (point !== undefined) {
+                            handleMoves.push({
+                                elementId: element.id,
+                                fromPosition: point,
+                                toPosition: {
+                                    x: point.x + dx,
+                                    y: point.y + dy
+                                }
+                            });
+                        }
+                    }
+                });
+            this.lastDragPosition = { x: event.pageX, y: event.pageY };
+            if (handleMoves.length > 0) {
+                result.push(new MoveAction(handleMoves, false));
+            }
+        }
+        return result;
+    }
+
+    protected getHandlePosition(handle: SRoutingHandle): Point | undefined {
+        if (this.edgeRouterRegistry) {
+            const parent = handle.parent;
+            if (!isRoutable(parent)) {
+                return undefined;
+            }
+            const router = this.edgeRouterRegistry.get(parent.routerKind);
+            const route = router.route(parent);
+            return router.getHandlePosition(parent, route, handle);
+        }
+        return undefined;
+    }
+
+    mouseEnter(target: SModelElement, event: MouseEvent): Action[] {
+        if (target instanceof SModelRoot && event.buttons === 0) {
+            this.mouseUp(target, event);
+        }
+        return [];
+    }
+
+    mouseUp(_target: SModelElement, event: MouseEvent): Action[] {
+        this.hasDragged = false;
+        this.lastDragPosition = undefined;
+        return [];
+    }
+
+    decorate(vnode: VNode, _element: SModelElement): VNode {
+        return vnode;
+    }
+}
+
+/**
+ * UTILITY FUNCTIONS
+ */
+
+function drawFeedbackEdgeSource(context: CommandExecutionContext, targetId: string, elementTypeId: string): void {
+    const root = context.root;
+    const targetChild = root.index.getById(targetId);
+    if (!targetChild) {
+        return;
+    }
+
+    const target = findParentByFeature(targetChild, isConnectable);
+    if (!target || !isBoundsAware(target)) {
+        return;
+    }
+
+    const edgeEnd = new FeedbackEdgeEnd(target.id, elementTypeId);
+    edgeEnd.id = feedbackEdgeEndId(root);
+    edgeEnd.position = { x: target.bounds.x, y: target.bounds.y };
+
+    const feedbackEdgeSchema = {
+        type: 'edge',
+        id: feedbackEdgeId(root),
+        sourceId: edgeEnd.id,
+        targetId: target.id,
+        opacity: 0.3
+    };
+
+    const feedbackEdge = context.modelFactory.createElement(feedbackEdgeSchema);
+    if (isRoutable(feedbackEdge)) {
+        edgeEnd.feedbackEdge = feedbackEdge;
+        root.add(edgeEnd);
+        root.add(feedbackEdge);
+    }
+}

package/src/features/tool-feedback/feedback-action-dispatcher.ts

@@ -0,0 +1,101 @@
+/********************************************************************************
+ * 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, IActionDispatcher, ILogger, TYPES } from 'sprotty';
+
+export interface IFeedbackEmitter { }
+
+/**
+ * Dispatcher for actions that are meant to show visual feedback on
+ * the diagram that is not part of the diagram sent from the server
+ * after a model update.
+ *
+ * The purpose of this dispatcher is to re-establish the feedback
+ * after the model has been updated or reset by the server, as this would
+ * overwrite the already established feedback, in case it is drawn by
+ * extending the `SModelRoot`. Therefore, tools can register themselves
+ * as feedback emitters with actions they want to place for showing
+ * feedback. This dispatcher will then re-establish all feedback actions
+ * of the registered tools, whenever the `SModelRoot` has been set or updated.
+ */
+export interface IFeedbackActionDispatcher {
+    /**
+     * Registers `actions` to be sent out by a `feedbackEmitter`.
+     * @param feedbackEmitter the emitter sending out feedback actions.
+     * @param actions the actions to be sent out.
+     */
+    registerFeedback(feedbackEmitter: IFeedbackEmitter, actions: Action[]): void;
+
+    /**
+     * Deregisters a `feedbackEmitter` from this dispatcher and thereafter
+     * dispatches the provided `actions`.
+     * @param feedbackEmitter the emitter to be deregistered.
+     * @param actions the actions to be dispatched right after the deregistration.
+     * These actions do not have to be related to the actions sent out by the
+     * deregistered `feedbackEmitter`. The purpose of these actions typically is
+     * to reset the normal state of the diagram without the feedback (e.g., reset a
+     * CSS class that was set by a feedbackEmitter).
+     */
+    deregisterFeedback(feedbackEmitter: IFeedbackEmitter, actions: Action[]): void;
+
+    /**
+    * Retrieve all `actions` sent out by currently registered `feedbackEmitter`.
+    */
+    getRegisteredFeedback(): Action[];
+}
+
+@injectable()
+export class FeedbackActionDispatcher implements IFeedbackActionDispatcher {
+    protected feedbackEmitters: Map<IFeedbackEmitter, Action[]> = new Map;
+
+    @inject(TYPES.IActionDispatcherProvider) protected actionDispatcher: () => Promise<IActionDispatcher>;
+    @inject(TYPES.ILogger) protected logger: ILogger;
+
+    registerFeedback(feedbackEmitter: IFeedbackEmitter, actions: Action[]): void {
+        this.feedbackEmitters.set(feedbackEmitter, actions);
+        this.dispatch(actions, feedbackEmitter);
+    }
+
+    deregisterFeedback(feedbackEmitter: IFeedbackEmitter, actions: Action[]): void {
+        this.feedbackEmitters.delete(feedbackEmitter);
+        this.dispatch(actions, feedbackEmitter);
+    }
+
+    private dispatch(actions: Action[], feedbackEmitter: IFeedbackEmitter): void {
+        this.actionDispatcher()
+            .then(dispatcher => dispatcher.dispatchAll(actions))
+            .then(() => this.logger.info(this, `Dispatched feedback actions for ${feedbackEmitter}`))
+            .catch(reason => this.logger.error(this, 'Failed to dispatch feedback actions', reason));
+    }
+
+    getRegisteredFeedback(): Action[] {
+        const result: Action[] = [];
+        this.feedbackEmitters.forEach((value, key) => result.push(...value));
+        return result;
+    }
+
+    getRegisteredFeedbackEmitters(action: Action): IFeedbackEmitter[] {
+        const result: IFeedbackEmitter[] = [];
+        this.feedbackEmitters.forEach((value, key) => {
+            if (value.find(a => a === action)) {
+                result.push(key);
+            }
+        }
+        );
+        return result;
+    }
+
+}

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

@@ -0,0 +1,104 @@
+/********************************************************************************
+ * 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,
+    AnchorComputerRegistry,
+    CommandExecutionContext,
+    CommandReturn,
+    MouseListener,
+    Point,
+    SChildElement,
+    SModelElement,
+    SModelRoot,
+    TYPES
+} from 'sprotty';
+
+import { FeedbackCommand } from './model';
+
+export class DrawMarqueeAction implements Action {
+    constructor(
+        public readonly startPoint: Point,
+        public readonly endPoint: Point,
+        public readonly kind: string = DrawMarqueeCommand.KIND) { }
+}
+
+@injectable()
+export class DrawMarqueeCommand extends FeedbackCommand {
+    static readonly KIND = 'drawMarquee';
+
+    constructor(@inject(TYPES.Action) protected action: DrawMarqueeAction) {
+        super();
+    }
+
+    execute(context: CommandExecutionContext): CommandReturn {
+        drawMarquee(context, this.action.startPoint, this.action.endPoint);
+        return context.root;
+    }
+}
+
+export class RemoveMarqueeAction implements Action {
+    constructor(public readonly kind: string = RemoveMarqueeCommand.KIND) { }
+}
+
+@injectable()
+export class RemoveMarqueeCommand extends FeedbackCommand {
+    static readonly KIND = 'removeMarqueeCommand';
+
+    execute(context: CommandExecutionContext): CommandReturn {
+        removeMarquee(context.root);
+        return context.root;
+    }
+}
+
+export class MarqueeEndMovingMouseListener extends MouseListener {
+    constructor(protected anchorRegistry: AnchorComputerRegistry) {
+        super();
+    }
+
+    mouseMove(target: SModelElement, event: MouseEvent): Action[] {
+        return [];
+    }
+}
+
+export function marqueeId(root: SModelRoot): string {
+    return root.id + '_' + MARQUEE;
+}
+
+export const MARQUEE = 'marquee';
+
+export function drawMarquee(context: CommandExecutionContext, startPoint: Point, endPoint: Point): void {
+    const root = context.root;
+
+    removeMarquee(root);
+
+    const marqueeSchema = {
+        type: MARQUEE,
+        id: marqueeId(root),
+        startPoint: startPoint,
+        endPoint: endPoint
+    };
+
+    const marquee = context.modelFactory.createElement(marqueeSchema);
+    root.add(marquee);
+}
+
+export function removeMarquee(root: SModelRoot): void {
+    const marquee = root.index.getById(marqueeId(root));
+    if (marquee instanceof SChildElement) {
+        root.remove(marquee);
+    }
+}

package/src/features/tool-feedback/model.ts

@@ -0,0 +1,32 @@
+/********************************************************************************
+ * 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 { Command, CommandExecutionContext, CommandReturn } from 'sprotty';
+
+export abstract class FeedbackCommand extends Command {
+    // used by the `FeedbackAwareUpdateModelCommand`
+    readonly priority: number = 0;
+
+    abstract execute(context: CommandExecutionContext): CommandReturn;
+
+    undo(context: CommandExecutionContext): CommandReturn {
+        return context.root;
+    }
+
+    redo(context: CommandExecutionContext): CommandReturn {
+        return context.root;
+    }
+}
+

package/src/features/tool-feedback/view.tsx

@@ -0,0 +1,70 @@
+/********************************************************************************
+ * 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 { VNode } from 'snabbdom';
+import { IView, ORIGIN_POINT, Point, RenderingContext, setAttr, SModelElement, svg } from 'sprotty';
+
+import { isResizable, ResizeHandleLocation, SResizeHandle } from '../change-bounds/model';
+
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+const JSX = { createElement: svg };
+
+/**
+* This view is used for the invisible end of the feedback edge.
+* A feedback edge is shown as a visual feedback when creating edges.
+*/
+@injectable()
+export class FeedbackEdgeEndView implements IView {
+    render(model: Readonly<SModelElement>, context: RenderingContext): VNode {
+        const position: Point = (model as any).position || ORIGIN_POINT;
+        return <g x={position.x} y={position.y} />;
+    }
+}
+
+@injectable()
+export class SResizeHandleView implements IView {
+    render(handle: SResizeHandle, context: RenderingContext): VNode {
+        const position = this.getPosition(handle);
+        if (position !== undefined) {
+            const node = <circle class-sprotty-resize-handle={true} class-mouseover={handle.hoverFeedback}
+                cx={position.x} cy={position.y} r={this.getRadius()} />;
+            setAttr(node, 'data-kind', handle.location);
+            return node;
+        }
+        // Fallback: Create an empty group
+        return <g />;
+    }
+
+    protected getPosition(handle: SResizeHandle): Point | undefined {
+        const parent = handle.parent;
+        if (isResizable(parent)) {
+            if (handle.location === ResizeHandleLocation.TopLeft) {
+                return { x: 0, y: 0 };
+            } else if (handle.location === ResizeHandleLocation.TopRight) {
+                return { x: parent.bounds.width, y: 0 };
+            } else if (handle.location === ResizeHandleLocation.BottomLeft) {
+                return { x: 0, y: parent.bounds.height };
+            } else if (handle.location === ResizeHandleLocation.BottomRight) {
+                return { x: parent.bounds.width, y: parent.bounds.height };
+            }
+        }
+        return undefined;
+    }
+
+    getRadius(): number {
+        return 7;
+    }
+}

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

@@ -0,0 +1,30 @@
+/********************************************************************************
+ * 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/tool-palette.css';
+
+import { ContainerModule } from 'inversify';
+import { configureActionHandler, EnableDefaultToolsAction, TYPES } from 'sprotty';
+
+import { EnableToolPaletteAction, ToolPalette } from './tool-palette';
+
+const toolPaletteModule = new ContainerModule((bind, _unbind, isBound, rebind) => {
+    bind(ToolPalette).toSelf().inSingletonScope();
+    bind(TYPES.IUIExtension).toService(ToolPalette);
+    configureActionHandler({ bind, isBound }, EnableToolPaletteAction.KIND, ToolPalette);
+    configureActionHandler({ bind, isBound }, EnableDefaultToolsAction.KIND, ToolPalette);
+});
+
+export default toolPaletteModule;