@eclipse-glsp/client 0.10.0-next.ca17587.154 → 1.1.0-RC01

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

@@ -1,5 +1,5 @@
 /********************************************************************************
- * Copyright (c) 2019-2021 EclipseSource and others.
+ * 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
@@ -13,7 +13,7 @@
  *
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
-import { Action, Point } from '@eclipse-glsp/protocol';
+import { Action, hasStringProp, Point } from '@eclipse-glsp/protocol';
 import { inject, injectable } from 'inversify';
 import { VNode } from 'snabbdom';
 import {
@@ -31,34 +31,64 @@ import {
     SModelRoot,
     TYPES
 } from 'sprotty';
-import { isNotUndefined } from '../../utils/smodel-util';
+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 class ShowChangeBoundsToolResizeFeedbackAction implements Action {
-    constructor(readonly elementId?: string, public readonly kind: string = ShowChangeBoundsToolResizeFeedbackCommand.KIND) {}
+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 class HideChangeBoundsToolResizeFeedbackAction implements Action {
-    constructor(public readonly kind: string = HideChangeBoundsToolResizeFeedbackCommand.KIND) {}
+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 = 'showChangeBoundsToolResizeFeedback';
+    static readonly KIND = ShowChangeBoundsToolResizeFeedbackAction.KIND;
 
     @inject(TYPES.Action) protected action: ShowChangeBoundsToolResizeFeedbackAction;
 
     execute(context: CommandExecutionContext): CommandReturn {
         const index = context.root.index;
-        index.all().filter(isResizable).forEach(removeResizeHandles);
 
-        if (isNotUndefined(this.action.elementId)) {
+        forEachElement(index, isResizable, removeResizeHandles);
+
+        if (this.action.elementId) {
             const resizeElement = index.getById(this.action.elementId);
-            if (isNotUndefined(resizeElement) && isResizable(resizeElement)) {
+            if (resizeElement && isResizable(resizeElement)) {
                 addResizeHandles(resizeElement);
             }
         }
@@ -68,13 +98,13 @@ export class ShowChangeBoundsToolResizeFeedbackCommand extends FeedbackCommand {
 
 @injectable()
 export class HideChangeBoundsToolResizeFeedbackCommand extends FeedbackCommand {
-    static readonly KIND = 'hideChangeBoundsToolResizeFeedback';
+    static readonly KIND = HideChangeBoundsToolResizeFeedbackAction.KIND;
 
     @inject(TYPES.Action) protected action: HideChangeBoundsToolResizeFeedbackAction;
 
     execute(context: CommandExecutionContext): CommandReturn {
         const index = context.root.index;
-        index.all().filter(isResizable).forEach(removeResizeHandles);
+        forEachElement(index, isResizable, removeResizeHandles);
         return context.root;
     }
 }
@@ -95,7 +125,7 @@ export class FeedbackMoveMouseListener extends MouseListener {
         super();
     }
 
-    mouseDown(target: SModelElement, event: MouseEvent): Action[] {
+    override mouseDown(target: SModelElement, event: MouseEvent): Action[] {
         if (event.button === 0 && !(target instanceof SResizeHandle)) {
             const moveable = findParentByFeature(target, isMoveable);
             if (moveable !== undefined) {
@@ -108,7 +138,7 @@ export class FeedbackMoveMouseListener extends MouseListener {
         return [];
     }
 
-    mouseMove(target: SModelElement, event: MouseEvent): Action[] {
+    override mouseMove(target: SModelElement, event: MouseEvent): Action[] {
         const result: Action[] = [];
         if (event.buttons === 0) {
             this.mouseUp(target, event);
@@ -148,7 +178,7 @@ export class FeedbackMoveMouseListener extends MouseListener {
         return false;
     }
 
-    protected getElementMoves(target: SModelElement, event: MouseEvent, isFinished: boolean): MoveAction | undefined {
+    protected getElementMoves(target: SModelElement, event: MouseEvent, finished: boolean): MoveAction | undefined {
         if (!this.startDragPosition) {
             return undefined;
         }
@@ -172,7 +202,7 @@ export class FeedbackMoveMouseListener extends MouseListener {
                 );
 
                 if (isMoveable(element)) {
-                    toPosition = this.validateMove(startPosition, toPosition, element, isFinished);
+                    toPosition = this.validateMove(startPosition, toPosition, element, finished);
                     elementMoves.push({
                         elementId: element.id,
                         fromPosition: {
@@ -185,7 +215,7 @@ export class FeedbackMoveMouseListener extends MouseListener {
             }
         });
         if (elementMoves.length > 0) {
-            return new MoveAction(elementMoves, false, isFinished);
+            return MoveAction.create(elementMoves, { animate: false, finished });
         } else {
             return undefined;
         }
@@ -194,7 +224,7 @@ export class FeedbackMoveMouseListener extends MouseListener {
     protected validateMove(startPostion: Point, toPosition: Point, element: SModelElement, isFinished: boolean): Point {
         let newPosition = toPosition;
         if (this.tool.movementRestrictor) {
-            const valid = this.tool.movementRestrictor.validate(toPosition, element);
+            const valid = this.tool.movementRestrictor.validate(element, toPosition);
             let action;
             if (!valid) {
                 action = createMovementRestrictionFeedback(element, this.tool.movementRestrictor);
@@ -219,14 +249,14 @@ export class FeedbackMoveMouseListener extends MouseListener {
         }
     }
 
-    mouseEnter(target: SModelElement, event: MouseEvent): Action[] {
+    override mouseEnter(target: SModelElement, event: MouseEvent): Action[] {
         if (target instanceof SModelRoot && event.buttons === 0 && !this.startDragPosition) {
             this.mouseUp(target, event);
         }
         return [];
     }
 
-    mouseUp(target: SModelElement, event: MouseEvent): Action[] {
+    override mouseUp(target: SModelElement, event: MouseEvent): Action[] {
         const result: Action[] = [];
         if (this.startDragPosition) {
             const moveAction = this.getElementMoves(target, event, true);
@@ -244,7 +274,7 @@ export class FeedbackMoveMouseListener extends MouseListener {
         return result;
     }
 
-    decorate(vnode: VNode, _element: SModelElement): VNode {
+    override decorate(vnode: VNode, _element: SModelElement): VNode {
         return vnode;
     }
 }

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

@@ -1,5 +1,5 @@
 /********************************************************************************
- * Copyright (c) 2019-2021 EclipseSource and others.
+ * 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
@@ -13,15 +13,12 @@
  *
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
-import { Action, Point } from '@eclipse-glsp/protocol';
+import { Action, Bounds, Point } from '@eclipse-glsp/protocol';
 import { inject, injectable } from 'inversify';
 import {
-    add,
     AnchorComputerRegistry,
-    center,
     CommandExecutionContext,
     CommandReturn,
-    euclideanDistance,
     findChildrenAtPosition,
     findParentByFeature,
     isBoundsAware,
@@ -32,28 +29,40 @@ import {
     SChildElement,
     SConnectableElement,
     SDanglingAnchor,
-    SEdgeSchema,
+    SEdge as SEdgeSchema,
     SModelElement,
     SModelRoot,
     SRoutableElement,
     TYPES
 } from 'sprotty';
-import { isRoutable } from '../../utils/smodel-util';
+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 class DrawFeedbackEdgeAction implements Action {
-    constructor(
-        public readonly elementTypeId: string,
-        public readonly sourceId: string,
-        public readonly edgeSchema?: SEdgeSchema,
-        public readonly kind: string = DrawFeedbackEdgeCommand.KIND
-    ) {}
+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 = 'drawFeedbackEdge';
+    static readonly KIND = DrawFeedbackEdgeAction.KIND;
 
     constructor(@inject(TYPES.Action) protected action: DrawFeedbackEdgeAction) {
         super();
@@ -66,13 +75,25 @@ export class DrawFeedbackEdgeCommand extends FeedbackCommand {
     }
 }
 
-export class RemoveFeedbackEdgeAction implements Action {
-    constructor(public readonly kind: string = RemoveFeedbackEdgeCommand.KIND) {}
+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 = 'removeFeedbackEdgeCommand';
+    static readonly KIND = RemoveFeedbackEdgeAction.KIND;
 
     execute(context: CommandExecutionContext): CommandReturn {
         removeFeedbackEdge(context.root);
@@ -86,7 +107,7 @@ export class FeedbackEdgeEnd extends SDanglingAnchor {
         readonly sourceId: string,
         readonly elementTypeId: string,
         public feedbackEdge: SRoutableElement | undefined = undefined,
-        public readonly type: string = FeedbackEdgeEnd.TYPE
+        override readonly type: string = FeedbackEdgeEnd.TYPE
     ) {
         super();
     }
@@ -97,7 +118,7 @@ export class FeedbackEdgeEndMovingMouseListener extends MouseListener {
         super();
     }
 
-    mouseMove(target: SModelElement, event: MouseEvent): Action[] {
+    override mouseMove(target: SModelElement, event: MouseEvent): Action[] {
         const root = target.root;
         const edgeEnd = root.index.getById(feedbackEdgeEndId(root));
         if (!(edgeEnd instanceof FeedbackEdgeEnd) || !edgeEnd.feedbackEdge) {
@@ -106,38 +127,66 @@ export class FeedbackEdgeEndMovingMouseListener extends MouseListener {
 
         const edge = edgeEnd.feedbackEdge;
         const position = getAbsolutePosition(edgeEnd, event);
-        const endAtMousePosition = findChildrenAtPosition(target.root, position).find(
-            element => isConnectable(element) && element.canConnect(edge, 'target')
-        );
+        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, center(edge.source.bounds));
-            if (euclideanDistance(anchor, edgeEnd.position) > 1) {
-                return [new MoveAction([{ elementId: edgeEnd.id, toPosition: anchor }], false)];
+            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 [new MoveAction([{ elementId: edgeEnd.id, toPosition: position }], false)];
+            return [MoveAction.create([{ elementId: edgeEnd.id, toPosition: position }], { animate: false })];
         }
 
         return [];
     }
 
-    protected computeAbsoluteAnchor(element: SConnectableElement, referencePoint: Point, offset?: number): Point {
+    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, referencePoint, offset);
+        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 = add(absoluteParentPosition, anchor);
+                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';
 }

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

@@ -1,5 +1,5 @@
 /********************************************************************************
- * Copyright (c) 2019-2021 EclipseSource and others.
+ * 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
@@ -13,50 +13,57 @@
  *
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
-import { Action, isStringArray } from '@eclipse-glsp/protocol';
+import { Action, hasArrayProp } from '@eclipse-glsp/protocol';
 import { inject, injectable } from 'inversify';
-import { CommandExecutionContext, SModelElement, SModelRoot, TYPES } from 'sprotty';
-import { addCssClasses, removeCssClasses } from '../../utils/smodel-util';
+import { CommandExecutionContext, SModelElement, SModelRoot } from 'sprotty';
+import { TYPES } from '../../base/types';
+import { addCssClasses, getElements, removeCssClasses } from '../../utils/smodel-util';
 import { FeedbackCommand } from './model';
 
-export class ModifyCSSFeedbackAction implements Action {
-    readonly elementIds?: string[];
+export interface ModifyCSSFeedbackAction extends Action {
+    kind: typeof ModifyCSSFeedbackAction.KIND;
 
-    constructor(
-        public readonly input?: string[] | SModelElement[],
-        public readonly addClasses?: string[],
-        public readonly removeClasses?: string[],
-        public kind = ModifyCssFeedbackCommand.KIND
-    ) {
-        if (input) {
-            this.elementIds = isStringArray(input) ? input : input.map(element => element.id);
-        }
+    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 = 'modifyCSSFeedback';
+    static readonly KIND = ModifyCSSFeedbackAction.KIND;
 
     constructor(@inject(TYPES.Action) readonly action: ModifyCSSFeedbackAction) {
         super();
     }
 
     execute(context: CommandExecutionContext): SModelRoot {
-        const elements: SModelElement[] = [];
-        if (this.action.elementIds) {
-            elements.push(...this.action.elementIds.map(elementId => context.root.index.getById(elementId)).filter(exists));
-        } else {
-            elements.push(context.root);
-        }
+        const elements = this.action.elementIds ? getElements(context.root.index, this.action.elementIds) : [context.root];
 
         elements.forEach(e => {
-            if (this.action.removeClasses) {
-                removeCssClasses(e, this.action.removeClasses);
+            if (this.action.remove) {
+                removeCssClasses(e, this.action.remove);
             }
 
-            if (this.action.addClasses) {
-                addCssClasses(e, this.action.addClasses);
+            if (this.action.add) {
+                addCssClasses(e, this.action.add);
             }
         });
 
@@ -64,10 +71,6 @@ export class ModifyCssFeedbackCommand extends FeedbackCommand {
     }
 }
 
-function exists(elt?: SModelElement): elt is SModelElement {
-    return elt !== undefined;
-}
-
 // eslint-disable-next-line no-shadow
 export enum CursorCSS {
     DEFAULT = 'default-mode',
@@ -85,17 +88,17 @@ export enum CursorCSS {
 }
 
 export function cursorFeedbackAction(cursorCss?: CursorCSS): ModifyCSSFeedbackAction {
-    const addCss = [];
+    const add = [];
     if (cursorCss) {
-        addCss.push(cursorCss);
+        add.push(cursorCss);
     }
-    return new ModifyCSSFeedbackAction(undefined, addCss, Object.values(CursorCSS));
+    return ModifyCSSFeedbackAction.create({ add, remove: Object.values(CursorCSS) });
 }
 
-export function applyCssClasses(element: SModelElement, ...classes: string[]): ModifyCSSFeedbackAction {
-    return new ModifyCSSFeedbackAction([element], classes, []);
+export function applyCssClasses(element: SModelElement, ...add: string[]): ModifyCSSFeedbackAction {
+    return ModifyCSSFeedbackAction.create({ elements: [element], add });
 }
 
-export function deleteCssClasses(element: SModelElement, ...classes: string[]): ModifyCSSFeedbackAction {
-    return new ModifyCSSFeedbackAction([element], [], classes);
+export function deleteCssClasses(element: SModelElement, ...remove: string[]): ModifyCSSFeedbackAction {
+    return ModifyCSSFeedbackAction.create({ elements: [element], remove });
 }

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

@@ -1,5 +1,5 @@
 /********************************************************************************
- * Copyright (c) 2019-2021 EclipseSource and others.
+ * 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
@@ -14,9 +14,8 @@
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
 import { ContainerModule } from 'inversify';
-import { configureCommand, configureView, LocationPostprocessor, MoveCommand, TYPES } from 'sprotty';
-
-import { GLSP_TYPES } from '../../base/types';
+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';
@@ -32,7 +31,7 @@ import { DrawMarqueeCommand, RemoveMarqueeCommand } from './marquee-tool-feedbac
 import { FeedbackEdgeEndView, SResizeHandleView } from './view';
 
 const toolFeedbackModule = new ContainerModule((bind, _unbind, isBound) => {
-    bind(GLSP_TYPES.IFeedbackActionDispatcher).to(FeedbackActionDispatcher).inSingletonScope();
+    bind(TYPES.IFeedbackActionDispatcher).to(FeedbackActionDispatcher).inSingletonScope();
 
     configureCommand({ bind, isBound }, ModifyCssFeedbackCommand);