@eclipse-glsp/client 2.2.0-next.335 → 2.2.0-next.337

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

@@ -37,17 +37,8 @@ import {
     TYPES,
     findParentByFeature
 } from '@eclipse-glsp/sprotty';
-import { CSS_RESIZE_MODE, ChangeBoundsManager, ChangeBoundsTracker, TrackedElementResize, TrackedResize } from '..';
 import { DragAwareMouseListener } from '../../../base/drag-aware-mouse-listener';
-import {
-    CursorCSS,
-    ModifyCSSFeedbackAction,
-    applyCssClasses,
-    cursorFeedbackAction,
-    deleteCssClasses,
-    toggleCssClasses
-} from '../../../base/feedback/css-feedback';
-import { FeedbackEmitter } from '../../../base/feedback/feeback-emitter';
+import { FeedbackEmitter } from '../../../base/feedback/feedback-emitter';
 import { ISelectionListener, SelectionService } from '../../../base/selection-service';
 import {
     BoundsAwareModelElement,
@@ -60,18 +51,16 @@ import {
 } from '../../../utils/gmodel-util';
 import { LocalRequestBoundsAction, SetBoundsFeedbackAction } from '../../bounds';
 import { SResizeHandle, isResizable } from '../../change-bounds/model';
-import {
-    IMovementRestrictor,
-    movementRestrictionFeedback,
-    removeMovementRestrictionFeedback
-} from '../../change-bounds/movement-restrictor';
+import { IMovementRestrictor } from '../../change-bounds/movement-restrictor';
 import { BaseEditTool } from '../base-tools';
+import { CSS_ACTIVE_HANDLE, ChangeBoundsManager } from './change-bounds-manager';
 import {
     HideChangeBoundsToolResizeFeedbackAction,
     MoveFinishedEventAction,
     ShowChangeBoundsToolResizeFeedbackAction
 } from './change-bounds-tool-feedback';
 import { FeedbackMoveMouseListener } from './change-bounds-tool-move-feedback';
+import { ChangeBoundsTracker, TrackedElementResize, TrackedResize } from './change-bounds-tracker';
 
 /**
  * The change bounds tool has the license to move multiple elements or resize a single element by implementing the ChangeBounds operation.
@@ -93,7 +82,7 @@ export class ChangeBoundsTool extends BaseEditTool {
     @inject(SelectionService) protected selectionService: SelectionService;
     @inject(EdgeRouterRegistry) @optional() readonly edgeRouterRegistry?: EdgeRouterRegistry;
     @inject(TYPES.IMovementRestrictor) @optional() readonly movementRestrictor?: IMovementRestrictor;
-    @inject(TYPES.IChangeBoundsManager) readonly changeBoundsManager: ChangeBoundsManager;
+    @inject(ChangeBoundsManager) readonly changeBoundsManager: ChangeBoundsManager;
 
     get id(): string {
         return ChangeBoundsTool.ID;
@@ -133,7 +122,7 @@ export class ChangeBoundsTool extends BaseEditTool {
 }
 
 export class ChangeBoundsListener extends DragAwareMouseListener implements ISelectionListener {
-    static readonly CSS_CLASS_ACTIVE = 'active';
+    static readonly CSS_CLASS_ACTIVE = CSS_ACTIVE_HANDLE;
 
     // members for calculating the correct position change
     protected initialBounds: ElementAndBounds | undefined;
@@ -206,15 +195,13 @@ export class ChangeBoundsListener extends DragAwareMouseListener implements ISel
         // consider resize handles ourselves
         if (this.activeResizeHandle && this.tracker.isTracking()) {
             const resize = this.tracker.resizeElements(this.activeResizeHandle, { snap: event, symmetric: event, restrict: event });
-            this.addResizeFeedback(resize, target, event);
             const resizeAction = this.resizeBoundsAction(resize);
             if (resizeAction.bounds.length > 0) {
                 this.resizeFeedback.add(resizeAction, () => this.resetBounds());
                 this.tracker.updateTrackingPosition(resize.handleMove.moveVector);
-            } else {
-                this.resizeFeedback.add(undefined, () => this.resetBounds());
+                this.addResizeFeedback(resize, target, event);
+                this.resizeFeedback.submit();
             }
-            this.resizeFeedback.submit();
         }
         return super.draggingMouseMove(target, event);
     }
@@ -234,40 +221,7 @@ export class ChangeBoundsListener extends DragAwareMouseListener implements ISel
     }
 
     protected addResizeFeedback(resize: TrackedResize, target: GModelElement, event: MouseEvent): void {
-        const handle = resize.handleMove.element;
-        // handle feedback
-        this.resizeFeedback.add(
-            applyCssClasses(handle, ChangeBoundsListener.CSS_CLASS_ACTIVE),
-            deleteCssClasses(handle, ChangeBoundsListener.CSS_CLASS_ACTIVE)
-        );
-
-        // graph feedback
-        this.resizeFeedback.add(
-            ModifyCSSFeedbackAction.create({ add: [CSS_RESIZE_MODE] }),
-            ModifyCSSFeedbackAction.create({ remove: [CSS_RESIZE_MODE] })
-        );
-
-        // cursor feedback
-        const cursorClass = SResizeHandle.getCursorCss(resize.handleMove.element);
-        this.resizeFeedback.add(cursorFeedbackAction(cursorClass), cursorFeedbackAction(CursorCSS.DEFAULT));
-
-        const movementRestrictor = this.tool.changeBoundsManager.movementRestrictor;
-        resize.elementResizes.forEach(elementResize => {
-            if (movementRestrictor) {
-                this.resizeFeedback.add(
-                    movementRestrictionFeedback(elementResize.element, movementRestrictor, elementResize.valid.move),
-                    removeMovementRestrictionFeedback(elementResize.element, movementRestrictor)
-                );
-            }
-            this.resizeFeedback.add(
-                toggleCssClasses(elementResize.element, !elementResize.valid.size, 'resize-not-allowed'),
-                deleteCssClasses(elementResize.element, 'resize-not-allowed')
-            );
-        });
-        this.resizeFeedback.add(
-            toggleCssClasses(resize.handleMove.element, !resize.valid.size, 'resize-not-allowed'),
-            deleteCssClasses(resize.handleMove.element, 'resize-not-allowed')
-        );
+        this.tool.changeBoundsManager.addResizeFeedback(this.resizeFeedback, resize, target, event);
     }
 
     protected resetBounds(): Action[] {

package/src/features/tools/change-bounds/change-bounds-tracker.ts

@@ -27,11 +27,13 @@ import {
     Vector,
     Writable,
     hasBooleanProp,
+    hasObjectProp,
+    isBoundsAware,
     isMoveable
 } from '@eclipse-glsp/sprotty';
-import { ChangeBoundsManager } from '..';
 import { BoundsAwareModelElement, MoveableElement, ResizableModelElement, getElements } from '../../../utils';
 import { DiagramMovementCalculator, ResizeHandleLocation, SResizeHandle } from '../../change-bounds';
+import { ChangeBoundsManager } from './change-bounds-manager';
 
 export interface ElementTrackingOptions {
     /** Snap position. Default: true. */
@@ -73,6 +75,17 @@ export interface TrackedElementMove extends ResolvedElementMove {
     valid: boolean;
 }
 
+export namespace TrackedElementMove {
+    export function is(obj: any): obj is TrackedElementMove {
+        return (
+            hasObjectProp(obj, 'element') &&
+            hasObjectProp(obj, 'fromPosition') &&
+            hasObjectProp(obj, 'toPosition') &&
+            hasBooleanProp(obj, 'valid')
+        );
+    }
+}
+
 export type TypedElementMove<T extends MoveableElement> = TrackedElementMove & { element: T };
 
 export interface TrackedMove extends Movement {
@@ -134,6 +147,14 @@ export interface TrackedElementResize {
     };
 }
 
+export namespace TrackedElementResize {
+    export function is(obj: any): obj is TrackedElementResize {
+        return (
+            isBoundsAware(obj.element) && hasObjectProp(obj, 'fromBounds') && hasObjectProp(obj, 'toBounds') && hasObjectProp(obj, 'valid')
+        );
+    }
+}
+
 export interface TrackedResize extends Movement {
     handleMove: TrackedHandleMove;
     elementResizes: TrackedElementResize[];
@@ -179,7 +200,7 @@ export class ChangeBoundsTracker {
         const update = this.calculateDiagramMovement();
         const move: TrackedMove = { ...update, elementMoves: [], valid: true, options };
 
-        if (Vector.isZero(update.vector)) {
+        if (Vector.isZero(update.vector) && options.skipStatic) {
             // no movement detected so elements won't be moved, exit early
             return move;
         }
@@ -260,13 +281,13 @@ export class ChangeBoundsTracker {
         const update = this.calculateDiagramMovement();
         const handleMove = this.calculateHandleMove(new MoveableResizeHandle(handle), update.vector, options);
         const resize: TrackedResize = { ...update, valid: { move: true, size: true }, options, handleMove, elementResizes: [] };
-        if (Vector.isZero(handleMove.moveVector)) {
+        if (Vector.isZero(handleMove.moveVector) && options.skipStatic) {
             // no movement detected so elements won't be moved, exit early
             return resize;
         }
 
         // calculate resize for each element (typically only one element is resized at a time but customizations are possible)
-        const elementsToResize = this.getResizeableElements(handle, options);
+        const elementsToResize = this.getResizableElements(handle, options);
         for (const element of elementsToResize) {
             const elementResize = this.calculateElementResize(element, handleMove, options);
             if (!this.skipElementResize(elementResize, options)) {
@@ -293,7 +314,7 @@ export class ChangeBoundsTracker {
         return this.calculateElementMove(handle, diagramMovement, moveOptions);
     }
 
-    protected getResizeableElements(handle: SResizeHandle, options: ResizeOptions): ResizableModelElement[] {
+    protected getResizableElements(handle: SResizeHandle, options: ResizeOptions): ResizableModelElement[] {
         return [handle.parent];
     }
 

package/src/features/tools/edge-creation/edge-creation-tool.ts

@@ -25,13 +25,14 @@ import {
     isConnectable,
     isCtrlOrCmd
 } from '@eclipse-glsp/sprotty';
-import { inject, injectable } from 'inversify';
+import { inject, injectable, optional } from 'inversify';
 import { FeedbackEmitter } from '../../../base';
 import { GLSPActionDispatcher } from '../../../base/action-dispatcher';
 import { DragAwareMouseListener } from '../../../base/drag-aware-mouse-listener';
 import { CursorCSS, cursorFeedbackAction } from '../../../base/feedback/css-feedback';
 import { EnableDefaultToolsAction } from '../../../base/tool-manager/tool';
 import { GEdge } from '../../../model';
+import { Grid } from '../../grid';
 import { ITypeHintProvider } from '../../hints/type-hint-provider';
 import { BaseCreationTool } from '../base-tools';
 import { DrawFeedbackEdgeAction, RemoveFeedbackEdgeAction } from './dangling-edge-feedback';
@@ -45,8 +46,8 @@ export class EdgeCreationTool extends BaseCreationTool<TriggerEdgeCreationAction
     static ID = 'tool_create_edge';
 
     @inject(AnchorComputerRegistry) protected anchorRegistry: AnchorComputerRegistry;
-
     @inject(TYPES.ITypeHintProvider) protected typeHintProvider: ITypeHintProvider;
+    @optional() @inject(TYPES.Grid) protected grid: Grid;
 
     protected isTriggerAction = TriggerEdgeCreationAction.is;
 
@@ -59,7 +60,13 @@ export class EdgeCreationTool extends BaseCreationTool<TriggerEdgeCreationAction
         const toolFeedback = this.createFeedbackEmitter()
             .add(cursorFeedbackAction(CursorCSS.OPERATION_NOT_ALLOWED), cursorFeedbackAction())
             .submit();
-        const creationListener = new EdgeCreationToolMouseListener(this.triggerAction, this.actionDispatcher, this.typeHintProvider, this);
+        const creationListener = new EdgeCreationToolMouseListener(
+            this.triggerAction,
+            this.actionDispatcher,
+            this.typeHintProvider,
+            this,
+            this.grid?.x / 2
+        );
         this.toDisposeOnDisable.push(
             mouseMovingFeedback,
             this.mouseTool.registerListener(mouseMovingFeedback),
@@ -70,7 +77,6 @@ export class EdgeCreationTool extends BaseCreationTool<TriggerEdgeCreationAction
     }
 }
 
-@injectable()
 export class EdgeCreationToolMouseListener extends DragAwareMouseListener {
     protected source?: string;
     protected target?: string;
@@ -85,9 +91,10 @@ export class EdgeCreationToolMouseListener extends DragAwareMouseListener {
         protected triggerAction: TriggerEdgeCreationAction,
         protected actionDispatcher: GLSPActionDispatcher,
         protected typeHintProvider: ITypeHintProvider,
-        protected tool: EdgeCreationTool
+        protected tool: EdgeCreationTool,
+        protected dragSensitivity?: number
     ) {
-        super();
+        super(dragSensitivity);
         this.proxyEdge = new GEdge();
         this.proxyEdge.type = triggerAction.elementTypeId;
         this.cursorFeedback = tool.createFeedbackEmitter();

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

@@ -41,13 +41,13 @@ import {
     typeGuard
 } from '@eclipse-glsp/sprotty';
 import { inject, injectable } from 'inversify';
-import { ChangeBoundsManager, ChangeBoundsTracker, MoveableRoutingHandle } from '..';
 import { FeedbackEmitter } from '../../../base';
 import { IFeedbackActionDispatcher } from '../../../base/feedback/feedback-action-dispatcher';
 import { FeedbackCommand } from '../../../base/feedback/feedback-command';
 import { forEachElement, getMatchingElements, isRoutable, isRoutingHandle } from '../../../utils/gmodel-util';
 import { getAbsolutePosition, toAbsoluteBounds } from '../../../utils/viewpoint-util';
 import { addReconnectHandles, removeReconnectHandles } from '../../reconnect/model';
+import { ChangeBoundsManager, ChangeBoundsTracker, MoveableRoutingHandle } from '../change-bounds';
 import { FeedbackEdgeEnd, feedbackEdgeEndId, feedbackEdgeId } from '../edge-creation/dangling-edge-feedback';
 import { FeedbackEdgeEndMovingMouseListener } from '../edge-creation/edge-creation-tool-feedback';
 

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

@@ -24,14 +24,12 @@ import {
     GRoutableElement,
     GRoutingHandle,
     ReconnectEdgeOperation,
-    TYPES,
     canEditRouting,
     findParentByFeature,
     isConnectable,
     isSelected
 } from '@eclipse-glsp/sprotty';
 import { inject, injectable, optional } from 'inversify';
-import { ChangeBoundsManager } from '..';
 import { FeedbackEmitter } from '../../../base';
 import { DragAwareMouseListener } from '../../../base/drag-aware-mouse-listener';
 import { CursorCSS, cursorFeedbackAction } from '../../../base/feedback/css-feedback';
@@ -39,6 +37,7 @@ import { ISelectionListener, SelectionService } from '../../../base/selection-se
 import { calcElementAndRoutingPoints, isRoutable, isRoutingHandle } from '../../../utils/gmodel-util';
 import { GReconnectHandle, isReconnectHandle, isReconnectable, isSourceRoutingHandle, isTargetRoutingHandle } from '../../reconnect/model';
 import { BaseEditTool } from '../base-tools';
+import { ChangeBoundsManager } from '../change-bounds';
 import { DrawFeedbackEdgeAction, RemoveFeedbackEdgeAction, feedbackEdgeId } from '../edge-creation/dangling-edge-feedback';
 import {
     DrawFeedbackEdgeSourceAction,
@@ -57,7 +56,7 @@ export class EdgeEditTool extends BaseEditTool {
     @inject(SelectionService) protected selectionService: SelectionService;
     @inject(AnchorComputerRegistry) protected anchorRegistry: AnchorComputerRegistry;
     @inject(EdgeRouterRegistry) @optional() readonly edgeRouterRegistry?: EdgeRouterRegistry;
-    @inject(TYPES.IChangeBoundsManager) readonly changeBoundsManager: ChangeBoundsManager;
+    @inject(ChangeBoundsManager) readonly changeBoundsManager: ChangeBoundsManager;
 
     protected feedbackEdgeSourceMovingListener: FeedbackEdgeSourceMovingMouseListener;
     protected feedbackEdgeTargetMovingListener: FeedbackEdgeTargetMovingMouseListener;

package/src/features/tools/node-creation/container-manager.ts

@@ -0,0 +1,76 @@
+/********************************************************************************
+ * Copyright (c) 2024 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 { GModelElement, Point, findChildrenAtPosition } from '@eclipse-glsp/sprotty';
+import { inject, injectable } from 'inversify';
+import { CSS_GHOST_ELEMENT, CursorCSS, FeedbackEmitter, cursorFeedbackAction } from '../../../base';
+import { ContainerElement, isContainable } from '../../hints';
+import { ChangeBoundsManager } from '../change-bounds';
+
+export interface TrackedInsert {
+    elementTypeId: string;
+    location: Point;
+    container?: GModelElement;
+    valid: boolean;
+}
+
+export interface InsertOptions extends Record<string, unknown> {
+    /** Flag to indicate whether the location within a container needs to be valid. Default: false */
+    validateLocationInContainer?: boolean;
+
+    /** Overwrite for location validation if validation result is already known. Default: undefined */
+    validLocationOverwrite?: boolean;
+
+    /** Mouse event to be used for finding the container. Default: undefined */
+    evt?: MouseEvent;
+}
+
+export const DEFAULT_INSERT_OPTIONS: InsertOptions = {
+    validateLocationInContainer: false
+};
+
+@injectable()
+export class ContainerManager {
+    @inject(ChangeBoundsManager) protected readonly changeBoundsManager: ChangeBoundsManager;
+
+    insert(proxy: GModelElement, location: Point, elementTypeId: string, opts?: Partial<InsertOptions>): TrackedInsert {
+        const options = { ...DEFAULT_INSERT_OPTIONS, ...opts };
+        const container = this.findContainer(location, proxy, opts?.evt);
+        let valid = !container || container.isContainableElement(elementTypeId);
+        if (valid && (!container || options.validateLocationInContainer)) {
+            // we need to check whether the location is valid either because we do not have a container or the option is set
+            valid = opts?.validLocationOverwrite ?? this.changeBoundsManager.hasValidPosition(proxy, location);
+        }
+        return { elementTypeId, container, location, valid };
+    }
+
+    findContainer(location: Point, ctx: GModelElement, evt?: MouseEvent): ContainerElement | undefined {
+        // reverse order of children to find the innermost, top-rendered containers first
+        return findChildrenAtPosition(ctx.root, location)
+            .reverse()
+            .find(element => isContainable(element) && !element.cssClasses?.includes(CSS_GHOST_ELEMENT)) as ContainerElement | undefined;
+    }
+
+    addInsertFeedback(feedback: FeedbackEmitter, trackedInsert: TrackedInsert, ctx?: GModelElement, event?: MouseEvent): FeedbackEmitter {
+        // cursor feedback
+        if (!trackedInsert.valid) {
+            feedback.add(cursorFeedbackAction(CursorCSS.OPERATION_NOT_ALLOWED), cursorFeedbackAction(CursorCSS.DEFAULT));
+        } else {
+            feedback.add(cursorFeedbackAction(CursorCSS.NODE_CREATION), cursorFeedbackAction());
+        }
+        return feedback;
+    }
+}

package/src/features/tools/node-creation/index.ts

@@ -13,5 +13,8 @@
  *
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
+export * from './container-manager';
+export * from './insert-indicator';
 export * from './node-creation-module';
 export * from './node-creation-tool';
+export * from './node-creation-views';

package/src/features/tools/node-creation/insert-indicator.ts

@@ -0,0 +1,41 @@
+/********************************************************************************
+ * Copyright (c) 2024 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 { Args, Dimension, FeatureSet, GNode, boundsFeature, createFeatureSet, moveFeature } from '@eclipse-glsp/sprotty';
+import { v4 as uuid } from 'uuid';
+import { ArgsAware, argsFeature } from '../../../base/args-feature';
+
+export const ARG_LENGTH = 'length';
+
+export class InsertIndicator extends GNode implements ArgsAware {
+    static override readonly DEFAULT_FEATURES = [boundsFeature, moveFeature, argsFeature];
+
+    static TYPE = 'node:insert-indicator';
+
+    override id: string = uuid();
+    override type: string = InsertIndicator.TYPE;
+    override features?: FeatureSet = createFeatureSet(InsertIndicator.DEFAULT_FEATURES);
+    override cssClasses: string[] = ['insert-indicator', 'sprotty-node'];
+    override size: Dimension = { width: 1, height: 1 };
+    args: Args = {};
+
+    constructor(length?: number) {
+        super();
+        if (length) {
+            this.args = { [ARG_LENGTH]: length };
+        }
+    }
+}

package/src/features/tools/node-creation/node-creation-module.ts

@@ -13,15 +13,27 @@
  *
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
-import { FeatureModule, TYPES, TriggerNodeCreationAction, bindAsService, configureActionHandler } from '@eclipse-glsp/sprotty';
+import {
+    FeatureModule,
+    TYPES,
+    TriggerNodeCreationAction,
+    bindAsService,
+    configureActionHandler,
+    configureModelElement
+} from '@eclipse-glsp/sprotty';
 import { elementTemplateModule } from '../../element-template/element-template-module';
+import { ContainerManager } from './container-manager';
+import { InsertIndicator } from './insert-indicator';
 import { NodeCreationTool } from './node-creation-tool';
+import { InsertIndicatorView } from './node-creation-views';
 
 export const nodeCreationToolModule = new FeatureModule(
     (bind, unbind, isBound, rebind) => {
         const context = { bind, unbind, isBound, rebind };
+        bind(ContainerManager).toSelf().inSingletonScope();
         bindAsService(context, TYPES.ITool, NodeCreationTool);
         configureActionHandler(context, TriggerNodeCreationAction.KIND, NodeCreationTool);
+        configureModelElement(context, InsertIndicator.TYPE, InsertIndicator, InsertIndicatorView);
     },
     { requires: elementTemplateModule }
 );