@eclipse-glsp/client 1.1.0-next.fdfeeeb.193 → 2.1.0-next.12ca798.289

package/src/features/tool-feedback/change-bounds-tool-feedback.ts

@@ -1,280 +0,0 @@
-/********************************************************************************
- * Copyright (c) 2019-2022 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, hasStringProp, Point } from '@eclipse-glsp/protocol';
-import { inject, injectable } from 'inversify';
-import { VNode } from 'snabbdom';
-import {
-    CommandExecutionContext,
-    CommandReturn,
-    ElementMove,
-    findParentByFeature,
-    isMoveable,
-    isSelectable,
-    isViewport,
-    MouseListener,
-    MoveAction,
-    SChildElement,
-    SModelElement,
-    SModelRoot,
-    TYPES
-} from 'sprotty';
-import { forEachElement } from '../../utils/smodel-util';
-import { addResizeHandles, isResizable, removeResizeHandles, SResizeHandle } from '../change-bounds/model';
-import { createMovementRestrictionFeedback, removeMovementRestrictionFeedback } from '../change-bounds/movement-restrictor';
-import { CursorCSS, cursorFeedbackAction } from '../tool-feedback/css-feedback';
-import { ChangeBoundsTool } from '../tools/change-bounds-tool';
-import { FeedbackCommand } from './model';
-
-export interface ShowChangeBoundsToolResizeFeedbackAction extends Action {
-    kind: typeof ShowChangeBoundsToolResizeFeedbackAction.KIND;
-
-    elementId: string;
-}
-
-export namespace ShowChangeBoundsToolResizeFeedbackAction {
-    export const KIND = 'showChangeBoundsToolResizeFeedback';
-
-    export function is(object: any): object is ShowChangeBoundsToolResizeFeedbackAction {
-        return Action.hasKind(object, KIND) && hasStringProp(object, 'elementId');
-    }
-
-    export function create(elementId: string): ShowChangeBoundsToolResizeFeedbackAction {
-        return {
-            kind: KIND,
-            elementId
-        };
-    }
-}
-
-export interface HideChangeBoundsToolResizeFeedbackAction extends Action {
-    kind: typeof HideChangeBoundsToolResizeFeedbackAction.KIND;
-}
-
-export namespace HideChangeBoundsToolResizeFeedbackAction {
-    export const KIND = 'hideChangeBoundsToolResizeFeedback';
-
-    export function is(object: any): object is HideChangeBoundsToolResizeFeedbackAction {
-        return Action.hasKind(object, KIND);
-    }
-
-    export function create(): HideChangeBoundsToolResizeFeedbackAction {
-        return { kind: KIND };
-    }
-}
-
-@injectable()
-export class ShowChangeBoundsToolResizeFeedbackCommand extends FeedbackCommand {
-    static readonly KIND = ShowChangeBoundsToolResizeFeedbackAction.KIND;
-
-    @inject(TYPES.Action) protected action: ShowChangeBoundsToolResizeFeedbackAction;
-
-    execute(context: CommandExecutionContext): CommandReturn {
-        const index = context.root.index;
-
-        forEachElement(index, isResizable, removeResizeHandles);
-
-        if (this.action.elementId) {
-            const resizeElement = index.getById(this.action.elementId);
-            if (resizeElement && isResizable(resizeElement)) {
-                addResizeHandles(resizeElement);
-            }
-        }
-        return context.root;
-    }
-}
-
-@injectable()
-export class HideChangeBoundsToolResizeFeedbackCommand extends FeedbackCommand {
-    static readonly KIND = HideChangeBoundsToolResizeFeedbackAction.KIND;
-
-    @inject(TYPES.Action) protected action: HideChangeBoundsToolResizeFeedbackAction;
-
-    execute(context: CommandExecutionContext): CommandReturn {
-        const index = context.root.index;
-        forEachElement(index, isResizable, removeResizeHandles);
-        return context.root;
-    }
-}
-
-/**
- * This mouse listener provides visual feedback for moving by sending client-side
- * `MoveAction`s while elements are selected and dragged. This will also update
- * their bounds, which is important, as it is not only required for rendering
- * the visual feedback but also the basis for sending the change to the server
- * (see also `tools/MoveTool`).
- */
-export class FeedbackMoveMouseListener extends MouseListener {
-    protected hasDragged = false;
-    protected startDragPosition: Point | undefined;
-    protected elementId2startPos = new Map<string, Point>();
-
-    constructor(protected tool: ChangeBoundsTool) {
-        super();
-    }
-
-    override mouseDown(target: SModelElement, event: MouseEvent): Action[] {
-        if (event.button === 0 && !(target instanceof SResizeHandle)) {
-            const moveable = findParentByFeature(target, isMoveable);
-            if (moveable !== undefined) {
-                this.startDragPosition = { x: event.pageX, y: event.pageY };
-            } else {
-                this.startDragPosition = undefined;
-            }
-            this.hasDragged = false;
-        }
-        return [];
-    }
-
-    override mouseMove(target: SModelElement, event: MouseEvent): Action[] {
-        const result: Action[] = [];
-        if (event.buttons === 0) {
-            this.mouseUp(target, event);
-        } else if (this.startDragPosition) {
-            if (this.elementId2startPos.size === 0) {
-                this.collectStartPositions(target.root);
-            }
-            this.hasDragged = true;
-            const moveAction = this.getElementMoves(target, event, false);
-            if (moveAction) {
-                result.push(moveAction);
-                result.push(cursorFeedbackAction(CursorCSS.MOVE));
-            }
-        }
-        return result;
-    }
-
-    protected collectStartPositions(root: SModelRoot): void {
-        const selectedElements = root.index.all().filter(element => isSelectable(element) && element.selected);
-        const elementsSet = new Set(selectedElements);
-        selectedElements
-            .filter(element => !this.isChildOfSelected(elementsSet, element))
-            .forEach(element => {
-                if (isMoveable(element)) {
-                    this.elementId2startPos.set(element.id, element.position);
-                }
-            });
-    }
-
-    protected isChildOfSelected(selectedElements: Set<SModelElement>, element: SModelElement): boolean {
-        while (element instanceof SChildElement) {
-            element = element.parent;
-            if (selectedElements.has(element)) {
-                return true;
-            }
-        }
-        return false;
-    }
-
-    protected getElementMoves(target: SModelElement, event: MouseEvent, finished: boolean): MoveAction | undefined {
-        if (!this.startDragPosition) {
-            return undefined;
-        }
-        const elementMoves: ElementMove[] = [];
-        const viewport = findParentByFeature(target, isViewport);
-        const zoom = viewport ? viewport.zoom : 1;
-        const delta = {
-            x: (event.pageX - this.startDragPosition.x) / zoom,
-            y: (event.pageY - this.startDragPosition.y) / zoom
-        };
-        this.elementId2startPos.forEach((startPosition, elementId) => {
-            const element = target.root.index.getById(elementId);
-            if (element) {
-                let toPosition = this.snap(
-                    {
-                        x: startPosition.x + delta.x,
-                        y: startPosition.y + delta.y
-                    },
-                    element,
-                    !event.shiftKey
-                );
-
-                if (isMoveable(element)) {
-                    toPosition = this.validateMove(startPosition, toPosition, element, finished);
-                    elementMoves.push({
-                        elementId: element.id,
-                        fromPosition: {
-                            x: element.position.x,
-                            y: element.position.y
-                        },
-                        toPosition
-                    });
-                }
-            }
-        });
-        if (elementMoves.length > 0) {
-            return MoveAction.create(elementMoves, { animate: false, finished });
-        } else {
-            return undefined;
-        }
-    }
-
-    protected validateMove(startPostion: Point, toPosition: Point, element: SModelElement, isFinished: boolean): Point {
-        let newPosition = toPosition;
-        if (this.tool.movementRestrictor) {
-            const valid = this.tool.movementRestrictor.validate(element, toPosition);
-            let action;
-            if (!valid) {
-                action = createMovementRestrictionFeedback(element, this.tool.movementRestrictor);
-
-                if (isFinished) {
-                    newPosition = startPostion;
-                }
-            } else {
-                action = removeMovementRestrictionFeedback(element, this.tool.movementRestrictor);
-            }
-
-            this.tool.dispatchFeedback([action], this);
-        }
-        return newPosition;
-    }
-
-    protected snap(position: Point, element: SModelElement, isSnap: boolean): Point {
-        if (isSnap && this.tool.snapper) {
-            return this.tool.snapper.snap(position, element);
-        } else {
-            return position;
-        }
-    }
-
-    override mouseEnter(target: SModelElement, event: MouseEvent): Action[] {
-        if (target instanceof SModelRoot && event.buttons === 0 && !this.startDragPosition) {
-            this.mouseUp(target, event);
-        }
-        return [];
-    }
-
-    override mouseUp(target: SModelElement, event: MouseEvent): Action[] {
-        const result: Action[] = [];
-        if (this.startDragPosition) {
-            const moveAction = this.getElementMoves(target, event, true);
-            if (moveAction) {
-                result.push(moveAction);
-            }
-            if (this.tool.movementRestrictor) {
-                this.tool.deregisterFeedback([removeMovementRestrictionFeedback(target, this.tool.movementRestrictor)], this);
-            }
-            result.push(cursorFeedbackAction(CursorCSS.DEFAULT));
-        }
-        this.hasDragged = false;
-        this.startDragPosition = undefined;
-        this.elementId2startPos.clear();
-        return result;
-    }
-
-    override decorate(vnode: VNode, _element: SModelElement): VNode {
-        return vnode;
-    }
-}

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

@@ -1,246 +0,0 @@
-/********************************************************************************
- * Copyright (c) 2019-2022 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, Bounds, Point } from '@eclipse-glsp/protocol';
-import { inject, injectable } from 'inversify';
-import {
-    AnchorComputerRegistry,
-    CommandExecutionContext,
-    CommandReturn,
-    findChildrenAtPosition,
-    findParentByFeature,
-    isBoundsAware,
-    isConnectable,
-    MouseListener,
-    MoveAction,
-    PolylineEdgeRouter,
-    SChildElement,
-    SConnectableElement,
-    SDanglingAnchor,
-    SEdge as SEdgeSchema,
-    SModelElement,
-    SModelRoot,
-    SRoutableElement,
-    TYPES
-} from 'sprotty';
-import { BoundsAwareModelElement, isRoutable } from '../../utils/smodel-util';
-import { getAbsolutePosition, toAbsoluteBounds, toAbsolutePosition } from '../../utils/viewpoint-util';
-import { FeedbackCommand } from './model';
-export interface DrawFeedbackEdgeAction extends Action {
-    kind: typeof DrawFeedbackEdgeAction.KIND;
-    elementTypeId: string;
-    sourceId: string;
-    edgeSchema?: SEdgeSchema;
-}
-
-export namespace DrawFeedbackEdgeAction {
-    export const KIND = 'drawFeedbackEdge';
-
-    export function is(object: any): object is DrawFeedbackEdgeAction {
-        return Action.hasKind(object, KIND);
-    }
-
-    export function create(options: { elementTypeId: string; sourceId: string; edgeSchema?: SEdgeSchema }): DrawFeedbackEdgeAction {
-        return {
-            kind: KIND,
-            ...options
-        };
-    }
-}
-
-@injectable()
-export class DrawFeedbackEdgeCommand extends FeedbackCommand {
-    static readonly KIND = DrawFeedbackEdgeAction.KIND;
-
-    constructor(@inject(TYPES.Action) protected action: DrawFeedbackEdgeAction) {
-        super();
-    }
-
-    execute(context: CommandExecutionContext): CommandReturn {
-        const feedbackEdgeSchema = this.action.edgeSchema ? this.action.edgeSchema : defaultFeedbackEdgeSchema;
-        drawFeedbackEdge(context, this.action.sourceId, this.action.elementTypeId, feedbackEdgeSchema);
-        return context.root;
-    }
-}
-
-export interface RemoveFeedbackEdgeAction extends Action {
-    kind: typeof RemoveFeedbackEdgeAction.KIND;
-}
-
-export namespace RemoveFeedbackEdgeAction {
-    export const KIND = 'removeFeedbackEdgeCommand';
-
-    export function is(object: any): object is RemoveFeedbackEdgeAction {
-        return Action.hasKind(object, KIND);
-    }
-
-    export function create(): RemoveFeedbackEdgeAction {
-        return { kind: KIND };
-    }
-}
-
-@injectable()
-export class RemoveFeedbackEdgeCommand extends FeedbackCommand {
-    static readonly KIND = RemoveFeedbackEdgeAction.KIND;
-
-    execute(context: CommandExecutionContext): CommandReturn {
-        removeFeedbackEdge(context.root);
-        return context.root;
-    }
-}
-
-export class FeedbackEdgeEnd extends SDanglingAnchor {
-    static readonly TYPE = 'feedback-edge-end';
-    constructor(
-        readonly sourceId: string,
-        readonly elementTypeId: string,
-        public feedbackEdge: SRoutableElement | undefined = undefined,
-        override readonly type: string = FeedbackEdgeEnd.TYPE
-    ) {
-        super();
-    }
-}
-
-export class FeedbackEdgeEndMovingMouseListener extends MouseListener {
-    constructor(protected anchorRegistry: AnchorComputerRegistry) {
-        super();
-    }
-
-    override 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)
-            .reverse()
-            .find(element => isConnectable(element) && element.canConnect(edge, 'target'));
-
-        if (endAtMousePosition instanceof SConnectableElement && edge.source && isBoundsAware(edge.source)) {
-            const anchor = this.computeAbsoluteAnchor(endAtMousePosition, Bounds.center(toAbsoluteBounds(edge.source)));
-            if (Point.euclideanDistance(anchor, edgeEnd.position) > 1) {
-                return [MoveAction.create([{ elementId: edgeEnd.id, toPosition: anchor }], { animate: false })];
-            }
-        } else {
-            return [MoveAction.create([{ elementId: edgeEnd.id, toPosition: position }], { animate: false })];
-        }
-
-        return [];
-    }
-
-    protected computeAbsoluteAnchor(element: SConnectableElement, absoluteReferencePoint: Point, offset?: number): Point {
-        const referencePointInParent = absoluteToParent(element, absoluteReferencePoint);
-        const anchorComputer = this.anchorRegistry.get(PolylineEdgeRouter.KIND, element.anchorKind);
-        let anchor = anchorComputer.getAnchor(element, referencePointInParent, 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 = Point.add(absoluteParentPosition, anchor);
-            }
-        }
-        return anchor;
-    }
-}
-
-/**
- * Convert a point, specified in absolute coordinates, to a point relative
- * to the parent of the specified child element.
- * @param element the child element
- * @param absolutePoint a point in absolute coordinates
- * @returns the equivalent point, relative to the element's parent coordinates
- */
-function absoluteToParent(element: BoundsAwareModelElement & SChildElement, absolutePoint: Point): Point {
-    if (isBoundsAware(element.parent)) {
-        return absoluteToLocal(element.parent, absolutePoint);
-    }
-    // If the parent is not bounds-aware, assume it's at 0; 0 and proceed
-    return absoluteToLocal(element, absolutePoint);
-}
-
-/**
- * Convert a point, specified in absolute coordinates, to a point relative
- * to the specified element.
- * @param element the element
- * @param absolutePoint a point in absolute coordinates
- * @returns the equivalent point, relative to the element's coordinates
- */
-function absoluteToLocal(element: BoundsAwareModelElement, absolutePoint: Point): Point {
-    const absoluteElementBounds = toAbsoluteBounds(element);
-    return { x: absolutePoint.x - absoluteElementBounds.x, y: absolutePoint.y - absoluteElementBounds.y };
-}
-
-export function feedbackEdgeId(root: SModelRoot): string {
-    return root.id + '_feedback_edge';
-}
-
-export function feedbackEdgeEndId(root: SModelRoot): string {
-    return root.id + '_feedback_anchor';
-}
-
-export const defaultFeedbackEdgeSchema: SEdgeSchema = {
-    cssClasses: ['feedback-edge'],
-    opacity: 0.3
-} as SEdgeSchema;
-
-export function drawFeedbackEdge(
-    context: CommandExecutionContext,
-    sourceId: string,
-    elementTypeId: string,
-    feedbackEdgeSchema: SEdgeSchema
-): void {
-    const root = context.root;
-    const sourceChild = root.index.getById(sourceId);
-    if (!sourceChild) {
-        return;
-    }
-
-    const source = findParentByFeature(sourceChild, isConnectable);
-    if (!source || !isBoundsAware(source)) {
-        return;
-    }
-
-    const edgeEnd = new FeedbackEdgeEnd(source.id, elementTypeId);
-    edgeEnd.id = feedbackEdgeEndId(root);
-    edgeEnd.position = toAbsolutePosition(source);
-
-    feedbackEdgeSchema.id = feedbackEdgeId(root);
-    feedbackEdgeSchema.type = elementTypeId;
-    feedbackEdgeSchema.sourceId = source.id;
-    feedbackEdgeSchema.targetId = edgeEnd.id;
-
-    const feedbackEdge = context.modelFactory.createElement(feedbackEdgeSchema);
-    if (isRoutable(feedbackEdge)) {
-        edgeEnd.feedbackEdge = feedbackEdge;
-        root.add(edgeEnd);
-        root.add(feedbackEdge);
-    }
-}
-
-export function removeFeedbackEdge(root: SModelRoot): void {
-    const feedbackEdge = root.index.getById(feedbackEdgeId(root));
-    const feedbackEdgeEnd = root.index.getById(feedbackEdgeEndId(root));
-    if (feedbackEdge instanceof SChildElement) {
-        root.remove(feedbackEdge);
-    }
-    if (feedbackEdgeEnd instanceof SChildElement) {
-        root.remove(feedbackEdgeEnd);
-    }
-}

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

@@ -1,104 +0,0 @@
-/********************************************************************************
- * Copyright (c) 2019-2022 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, hasArrayProp } from '@eclipse-glsp/protocol';
-import { inject, injectable } from 'inversify';
-import { CommandExecutionContext, SModelElement, SModelRoot } from 'sprotty';
-import { TYPES } from '../../base/types';
-import { addCssClasses, getElements, removeCssClasses } from '../../utils/smodel-util';
-import { FeedbackCommand } from './model';
-
-export interface ModifyCSSFeedbackAction extends Action {
-    kind: typeof ModifyCSSFeedbackAction.KIND;
-
-    elementIds?: string[];
-    add?: string[];
-    remove?: string[];
-}
-
-export namespace ModifyCSSFeedbackAction {
-    export const KIND = 'modifyCSSFeedback';
-
-    export function is(object: any): object is ModifyCSSFeedbackAction {
-        return Action.hasKind(object, KIND) && hasArrayProp(object, 'elementIds');
-    }
-
-    export function create(options: { elements?: (string | SModelElement)[]; add?: string[]; remove?: string[] }): ModifyCSSFeedbackAction {
-        const { elements, ...rest } = options;
-        const elementIds = elements ? elements.map(element => (typeof element === 'string' ? element : element.id)) : undefined;
-        return {
-            kind: KIND,
-            elementIds,
-            ...rest
-        };
-    }
-}
-
-@injectable()
-export class ModifyCssFeedbackCommand extends FeedbackCommand {
-    static readonly KIND = ModifyCSSFeedbackAction.KIND;
-
-    constructor(@inject(TYPES.Action) readonly action: ModifyCSSFeedbackAction) {
-        super();
-    }
-
-    execute(context: CommandExecutionContext): SModelRoot {
-        const elements = this.action.elementIds ? getElements(context.root.index, this.action.elementIds) : [context.root];
-
-        elements.forEach(e => {
-            if (this.action.remove) {
-                removeCssClasses(e, this.action.remove);
-            }
-
-            if (this.action.add) {
-                addCssClasses(e, this.action.add);
-            }
-        });
-
-        return context.root;
-    }
-}
-
-// eslint-disable-next-line no-shadow
-export enum CursorCSS {
-    DEFAULT = 'default-mode',
-    OVERLAP_FORBIDDEN = 'overlap-forbidden-mode',
-    NODE_CREATION = 'node-creation-mode',
-    EDGE_CREATION_SOURCE = 'edge-creation-select-source-mode',
-    EDGE_CREATION_TARGET = 'edge-creation-select-target-mode',
-    EDGE_RECONNECT = 'edge-reconnect-select-target-mode',
-    OPERATION_NOT_ALLOWED = 'edge-modification-not-allowed-mode',
-    ELEMENT_DELETION = 'element-deletion-mode',
-    RESIZE_NESW = 'resize-nesw-mode',
-    RESIZE_NWSE = 'resize-nwse-mode',
-    MOVE = 'move-mode',
-    MARQUEE = 'marquee-mode'
-}
-
-export function cursorFeedbackAction(cursorCss?: CursorCSS): ModifyCSSFeedbackAction {
-    const add = [];
-    if (cursorCss) {
-        add.push(cursorCss);
-    }
-    return ModifyCSSFeedbackAction.create({ add, remove: Object.values(CursorCSS) });
-}
-
-export function applyCssClasses(element: SModelElement, ...add: string[]): ModifyCSSFeedbackAction {
-    return ModifyCSSFeedbackAction.create({ elements: [element], add });
-}
-
-export function deleteCssClasses(element: SModelElement, ...remove: string[]): ModifyCSSFeedbackAction {
-    return ModifyCSSFeedbackAction.create({ elements: [element], remove });
-}

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

@@ -1,65 +0,0 @@
-/********************************************************************************
- * Copyright (c) 2019-2022 EclipseSource and others.
- *
- * This program and the accompanying materials are made available under the
- * terms of the Eclipse Public License v. 2.0 which is available at
- * http://www.eclipse.org/legal/epl-2.0.
- *
- * This Source Code may also be made available under the following Secondary
- * Licenses when the conditions for such availability set forth in the Eclipse
- * Public License v. 2.0 are satisfied: GNU General Public License, version 2
- * with the GNU Classpath Exception which is available at
- * https://www.gnu.org/software/classpath/license.html.
- *
- * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
- ********************************************************************************/
-import { ContainerModule } from 'inversify';
-import { configureCommand, configureView, LocationPostprocessor, MoveCommand } from 'sprotty';
-import { TYPES } from '../../base/types';
-import { SResizeHandle } from '../change-bounds/model';
-import { HideChangeBoundsToolResizeFeedbackCommand, ShowChangeBoundsToolResizeFeedbackCommand } from './change-bounds-tool-feedback';
-import { DrawFeedbackEdgeCommand, FeedbackEdgeEnd, RemoveFeedbackEdgeCommand } from './creation-tool-feedback';
-import { ModifyCssFeedbackCommand } from './css-feedback';
-import {
-    DrawFeedbackEdgeSourceCommand,
-    HideEdgeReconnectHandlesFeedbackCommand,
-    ShowEdgeReconnectHandlesFeedbackCommand,
-    SwitchRoutingModeCommand
-} from './edge-edit-tool-feedback';
-import { FeedbackActionDispatcher } from './feedback-action-dispatcher';
-import { DrawMarqueeCommand, RemoveMarqueeCommand } from './marquee-tool-feedback';
-import { FeedbackEdgeEndView, SResizeHandleView } from './view';
-
-const toolFeedbackModule = new ContainerModule((bind, _unbind, isBound) => {
-    bind(TYPES.IFeedbackActionDispatcher).to(FeedbackActionDispatcher).inSingletonScope();
-
-    configureCommand({ bind, isBound }, ModifyCssFeedbackCommand);
-
-    // create node and edge tool feedback
-    configureCommand({ bind, isBound }, DrawFeedbackEdgeCommand);
-    configureCommand({ bind, isBound }, RemoveFeedbackEdgeCommand);
-
-    configureCommand({ bind, isBound }, DrawMarqueeCommand);
-    configureCommand({ bind, isBound }, RemoveMarqueeCommand);
-
-    configureView({ bind, isBound }, FeedbackEdgeEnd.TYPE, FeedbackEdgeEndView);
-    // move tool feedback: we use sprotties MoveCommand as client-side visual feedback
-    configureCommand({ bind, isBound }, MoveCommand);
-
-    // resize tool feedback
-    configureCommand({ bind, isBound }, ShowChangeBoundsToolResizeFeedbackCommand);
-    configureCommand({ bind, isBound }, HideChangeBoundsToolResizeFeedbackCommand);
-    configureView({ bind, isBound }, SResizeHandle.TYPE, SResizeHandleView);
-
-    // reconnect edge tool feedback
-    configureCommand({ bind, isBound }, ShowEdgeReconnectHandlesFeedbackCommand);
-    configureCommand({ bind, isBound }, HideEdgeReconnectHandlesFeedbackCommand);
-    configureCommand({ bind, isBound }, DrawFeedbackEdgeSourceCommand);
-
-    configureCommand({ bind, isBound }, SwitchRoutingModeCommand);
-
-    bind(TYPES.IVNodePostprocessor).to(LocationPostprocessor);
-    bind(TYPES.HiddenVNodePostprocessor).to(LocationPostprocessor);
-});
-
-export default toolFeedbackModule;