@eclipse-glsp/client 2.2.0-next.329 → 2.2.0-next.330

package/src/features/tools/edge-creation/dangling-edge-feedback.ts

@@ -13,24 +13,26 @@
  *
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
-import { inject, injectable } from 'inversify';
 import {
     Action,
     BindingContext,
     CommandExecutionContext,
     CommandReturn,
     GChildElement,
+    GDanglingAnchor,
+    GEdgeSchema,
     GModelRoot,
     GRoutableElement,
     TYPES,
     configureCommand,
     configureView,
+    deletableFeature,
     findParentByFeature,
     isBoundsAware,
-    isConnectable,
-    GDanglingAnchor,
-    GEdgeSchema
+    isConnectable
 } from '@eclipse-glsp/sprotty';
+import { inject, injectable } from 'inversify';
+import { feedbackFeature } from '../../../base';
 import { FeedbackCommand } from '../../../base/feedback/feedback-command';
 import { isRoutable } from '../../../utils/gmodel-util';
 import { toAbsolutePosition } from '../../../utils/viewpoint-util';
@@ -103,6 +105,7 @@ export class RemoveFeedbackEdgeCommand extends FeedbackCommand {
 }
 
 export class FeedbackEdgeEnd extends GDanglingAnchor {
+    static override readonly DEFAULT_FEATURES = [deletableFeature, feedbackFeature];
     static readonly TYPE = 'feedback-edge-end';
     constructor(
         readonly sourceId: string,

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

@@ -18,27 +18,31 @@ import {
     AnchorComputerRegistry,
     Bounds,
     Disposable,
+    GConnectableElement,
+    GModelElement,
     MouseListener,
     MoveAction,
     Point,
     PolylineEdgeRouter,
-    GConnectableElement,
-    GModelElement,
     findChildrenAtPosition,
     findParentByFeature,
     isBoundsAware,
     isConnectable
 } from '@eclipse-glsp/sprotty';
+import { FeedbackEmitter } from '../../../base';
 import { IFeedbackActionDispatcher } from '../../../base/feedback/feedback-action-dispatcher';
 import { absoluteToParent, getAbsolutePosition, toAbsoluteBounds } from '../../../utils/viewpoint-util';
 import { FeedbackEdgeEnd, feedbackEdgeEndId } from './dangling-edge-feedback';
 
 export class FeedbackEdgeEndMovingMouseListener extends MouseListener implements Disposable {
+    protected feedback: FeedbackEmitter;
+
     constructor(
         protected anchorRegistry: AnchorComputerRegistry,
         protected feedbackDispatcher: IFeedbackActionDispatcher
     ) {
         super();
+        this.feedback = feedbackDispatcher.createEmitter();
     }
 
     override mouseMove(target: GModelElement, event: MouseEvent): Action[] {
@@ -57,14 +61,10 @@ export class FeedbackEdgeEndMovingMouseListener extends MouseListener implements
         if (endAtMousePosition instanceof GConnectableElement && edge.source && isBoundsAware(edge.source)) {
             const anchor = this.computeAbsoluteAnchor(endAtMousePosition, Bounds.center(toAbsoluteBounds(edge.source)));
             if (Point.euclideanDistance(anchor, edgeEnd.position) > 1) {
-                this.feedbackDispatcher.registerFeedback(this, [
-                    MoveAction.create([{ elementId: edgeEnd.id, toPosition: anchor }], { animate: false })
-                ]);
+                this.feedback.add(MoveAction.create([{ elementId: edgeEnd.id, toPosition: anchor }], { animate: false })).submit();
             }
         } else {
-            this.feedbackDispatcher.registerFeedback(this, [
-                MoveAction.create([{ elementId: edgeEnd.id, toPosition: position }], { animate: false })
-            ]);
+            this.feedback.add(MoveAction.create([{ elementId: edgeEnd.id, toPosition: position }], { animate: false })).submit();
         }
 
         return [];
@@ -87,6 +87,6 @@ export class FeedbackEdgeEndMovingMouseListener extends MouseListener implements
     }
 
     dispose(): void {
-        this.feedbackDispatcher.deregisterFeedback(this);
+        this.feedback.dispose();
     }
 }

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

@@ -13,28 +13,29 @@
  *
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
-import { inject, injectable } from 'inversify';
 import {
     Action,
     AnchorComputerRegistry,
     CreateEdgeOperation,
-    RequestCheckEdgeAction,
     GModelElement,
+    RequestCheckEdgeAction,
     TYPES,
     TriggerEdgeCreationAction,
     findParentByFeature,
     isConnectable,
     isCtrlOrCmd
 } from '@eclipse-glsp/sprotty';
+import { inject, injectable } 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 { ITypeHintProvider } from '../../hints/type-hint-provider';
 import { BaseCreationTool } from '../base-tools';
 import { DrawFeedbackEdgeAction, RemoveFeedbackEdgeAction } from './dangling-edge-feedback';
 import { FeedbackEdgeEndMovingMouseListener } from './edge-creation-tool-feedback';
-import { GEdge } from '../../../model';
 
 /**
  * Tool to create connections in a Diagram, by selecting a source and target node.
@@ -55,16 +56,16 @@ export class EdgeCreationTool extends BaseCreationTool<TriggerEdgeCreationAction
 
     doEnable(): void {
         const mouseMovingFeedback = new FeedbackEdgeEndMovingMouseListener(this.anchorRegistry, this.feedbackDispatcher);
+        const toolFeedback = this.createFeedbackEmitter()
+            .add(cursorFeedbackAction(CursorCSS.OPERATION_NOT_ALLOWED), cursorFeedbackAction())
+            .submit();
+        const creationListener = new EdgeCreationToolMouseListener(this.triggerAction, this.actionDispatcher, this.typeHintProvider, this);
         this.toDisposeOnDisable.push(
             mouseMovingFeedback,
-            this.mouseTool.registerListener(
-                new EdgeCreationToolMouseListener(this.triggerAction, this.actionDispatcher, this.typeHintProvider, this)
-            ),
             this.mouseTool.registerListener(mouseMovingFeedback),
-            this.registerFeedback([cursorFeedbackAction(CursorCSS.OPERATION_NOT_ALLOWED)], this, [
-                RemoveFeedbackEdgeAction.create(),
-                cursorFeedbackAction()
-            ])
+            creationListener,
+            this.mouseTool.registerListener(creationListener),
+            toolFeedback
         );
     }
 }
@@ -77,6 +78,8 @@ export class EdgeCreationToolMouseListener extends DragAwareMouseListener {
     protected allowedTarget = false;
     protected proxyEdge: GEdge;
     protected pendingDynamicCheck = false;
+    protected cursorFeedback: FeedbackEmitter;
+    protected feedbackEdgeFeedback: FeedbackEmitter;
 
     constructor(
         protected triggerAction: TriggerEdgeCreationAction,
@@ -87,14 +90,8 @@ export class EdgeCreationToolMouseListener extends DragAwareMouseListener {
         super();
         this.proxyEdge = new GEdge();
         this.proxyEdge.type = triggerAction.elementTypeId;
-    }
-
-    protected reinitialize(): void {
-        this.source = undefined;
-        this.target = undefined;
-        this.currentTarget = undefined;
-        this.allowedTarget = false;
-        this.tool.registerFeedback([RemoveFeedbackEdgeAction.create()]);
+        this.cursorFeedback = tool.createFeedbackEmitter();
+        this.feedbackEdgeFeedback = tool.createFeedbackEmitter();
     }
 
     override nonDraggingMouseUp(_element: GModelElement, event: MouseEvent): Action[] {
@@ -103,9 +100,12 @@ export class EdgeCreationToolMouseListener extends DragAwareMouseListener {
             if (!this.isSourceSelected()) {
                 if (this.currentTarget && this.allowedTarget) {
                     this.source = this.currentTarget.id;
-                    this.tool.registerFeedback([
-                        DrawFeedbackEdgeAction.create({ elementTypeId: this.triggerAction.elementTypeId, sourceId: this.source })
-                    ]);
+                    this.feedbackEdgeFeedback
+                        .add(
+                            DrawFeedbackEdgeAction.create({ elementTypeId: this.triggerAction.elementTypeId, sourceId: this.source }),
+                            RemoveFeedbackEdgeAction.create()
+                        )
+                        .submit();
                 }
             } else if (this.currentTarget && this.allowedTarget) {
                 this.target = this.currentTarget.id;
@@ -122,11 +122,11 @@ export class EdgeCreationToolMouseListener extends DragAwareMouseListener {
                 if (!isCtrlOrCmd(event)) {
                     result.push(EnableDefaultToolsAction.create());
                 } else {
-                    this.reinitialize();
+                    this.dispose();
                 }
             }
         } else if (event.button === 2) {
-            this.reinitialize();
+            this.dispose();
             result.push(EnableDefaultToolsAction.create());
         }
         return result;
@@ -203,4 +203,14 @@ export class EdgeCreationToolMouseListener extends DragAwareMouseListener {
         const typeHint = this.typeHintProvider.getEdgeTypeHint(edgeTypeId);
         return typeHint?.dynamic ?? false;
     }
+
+    override dispose(): void {
+        this.source = undefined;
+        this.target = undefined;
+        this.currentTarget = undefined;
+        this.allowedTarget = false;
+        this.feedbackEdgeFeedback.dispose();
+        this.cursorFeedback.dispose();
+        super.dispose();
+    }
 }

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

@@ -40,16 +40,17 @@ import {
     isSelected
 } from '@eclipse-glsp/sprotty';
 import { inject, injectable } from 'inversify';
+import { FeedbackEmitter } from '../../../base';
 import { IFeedbackActionDispatcher } from '../../../base/feedback/feedback-action-dispatcher';
 import { FeedbackCommand } from '../../../base/feedback/feedback-command';
 import { forEachElement, isRoutable, isRoutingHandle } from '../../../utils/gmodel-util';
 import { getAbsolutePosition, toAbsoluteBounds } from '../../../utils/viewpoint-util';
+import { PointPositionUpdater } from '../../change-bounds/point-position-updater';
 import { PositionSnapper } from '../../change-bounds/position-snapper';
 import { useSnap } from '../../change-bounds/snap';
 import { addReconnectHandles, removeReconnectHandles } from '../../reconnect/model';
 import { FeedbackEdgeEnd, feedbackEdgeEndId, feedbackEdgeId } from '../edge-creation/dangling-edge-feedback';
 import { FeedbackEdgeEndMovingMouseListener } from '../edge-creation/edge-creation-tool-feedback';
-import { PointPositionUpdater } from '../../change-bounds/point-position-updater';
 
 /**
  * RECONNECT HANDLES FEEDBACK
@@ -198,11 +199,14 @@ export class FeedbackEdgeTargetMovingMouseListener extends FeedbackEdgeEndMoving
 }
 
 export class FeedbackEdgeSourceMovingMouseListener extends MouseListener implements Disposable {
+    protected feedback: FeedbackEmitter;
+
     constructor(
         protected anchorRegistry: AnchorComputerRegistry,
         protected feedbackDispatcher: IFeedbackActionDispatcher
     ) {
         super();
+        this.feedback = feedbackDispatcher.createEmitter();
     }
 
     override mouseMove(target: GModelElement, event: MouseEvent): Action[] {
@@ -221,14 +225,10 @@ export class FeedbackEdgeSourceMovingMouseListener extends MouseListener impleme
         if (endAtMousePosition instanceof GConnectableElement && edge.target && isBoundsAware(edge.target)) {
             const anchor = this.computeAbsoluteAnchor(endAtMousePosition, Bounds.center(edge.target.bounds));
             if (Point.euclideanDistance(anchor, edgeEnd.position) > 1) {
-                this.feedbackDispatcher.registerFeedback(this, [
-                    MoveAction.create([{ elementId: edgeEnd.id, toPosition: anchor }], { animate: false })
-                ]);
+                this.feedback.add(MoveAction.create([{ elementId: edgeEnd.id, toPosition: anchor }], { animate: false })).submit();
             }
         } else {
-            this.feedbackDispatcher.registerFeedback(this, [
-                MoveAction.create([{ elementId: edgeEnd.id, toPosition: position }], { animate: false })
-            ]);
+            this.feedback.add(MoveAction.create([{ elementId: edgeEnd.id, toPosition: position }], { animate: false })).submit();
         }
 
         return [];
@@ -250,7 +250,7 @@ export class FeedbackEdgeSourceMovingMouseListener extends MouseListener impleme
     }
 
     dispose(): void {
-        this.feedbackDispatcher.deregisterFeedback(this);
+        this.feedback.dispose();
     }
 }
 

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

@@ -18,7 +18,6 @@ import {
     AnchorComputerRegistry,
     ChangeRoutingPointsOperation,
     Connectable,
-    Disposable,
     EdgeRouterRegistry,
     GModelElement,
     GModelRoot,
@@ -31,6 +30,7 @@ import {
     isSelected
 } from '@eclipse-glsp/sprotty';
 import { inject, injectable, optional } from 'inversify';
+import { FeedbackEmitter } from '../../../base';
 import { DragAwareMouseListener } from '../../../base/drag-aware-mouse-listener';
 import { CursorCSS, cursorFeedbackAction } from '../../../base/feedback/css-feedback';
 import { ISelectionListener, SelectionService } from '../../../base/selection-service';
@@ -76,7 +76,7 @@ export class EdgeEditTool extends BaseEditTool {
         this.feedbackMovingListener = new FeedbackEdgeRouteMovingMouseListener(this.positionSnapper, this.edgeRouterRegistry);
 
         this.toDisposeOnDisable.push(
-            Disposable.create(() => this.edgeEditListener.reset()),
+            this.edgeEditListener,
             this.mouseTool.registerListener(this.edgeEditListener),
             this.feedbackEdgeSourceMovingListener,
             this.feedbackEdgeTargetMovingListener,
@@ -110,8 +110,11 @@ export class EdgeEditListener extends DragAwareMouseListener implements ISelecti
     // active reconnect handle data
     protected reconnectMode?: 'NEW_SOURCE' | 'NEW_TARGET';
 
+    protected editFeedback: FeedbackEmitter;
+
     constructor(protected tool: EdgeEditTool) {
         super();
+        this.editFeedback = this.tool.createFeedbackEmitter();
     }
 
     protected isValidEdge(edge?: GRoutableElement): edge is GRoutableElement {
@@ -119,21 +122,21 @@ export class EdgeEditListener extends DragAwareMouseListener implements ISelecti
     }
 
     protected setEdgeSelected(edge: GRoutableElement): void {
-        if (this.edge && this.edge.id !== edge.id) {
-            // reset from a previously selected edge
-            this.reset();
-        }
-
         this.edge = edge;
         // note: order is important here as we want the reconnect handles to cover the routing handles
-        const feedbackActions = [];
         if (canEditRouting(edge)) {
-            feedbackActions.push(SwitchRoutingModeAction.create({ elementsToActivate: [this.edge.id] }));
+            this.editFeedback.add(
+                SwitchRoutingModeAction.create({ elementsToActivate: [this.edge.id] }),
+                SwitchRoutingModeAction.create({ elementsToDeactivate: [this.edge.id] })
+            );
         }
         if (isReconnectable(edge)) {
-            feedbackActions.push(ShowEdgeReconnectHandlesFeedbackAction.create(this.edge.id));
+            this.editFeedback.add(
+                ShowEdgeReconnectHandlesFeedbackAction.create(this.edge.id),
+                HideEdgeReconnectHandlesFeedbackAction.create()
+            );
         }
-        this.tool.registerFeedback(feedbackActions);
+        this.editFeedback.submit();
     }
 
     protected isEdgeSelected(): boolean {
@@ -142,19 +145,24 @@ export class EdgeEditListener extends DragAwareMouseListener implements ISelecti
 
     protected setReconnectHandleSelected(edge: GRoutableElement, reconnectHandle: GReconnectHandle): void {
         if (this.edge && this.edge.target && this.edge.source) {
+            this.editFeedback.dispose();
             if (isSourceRoutingHandle(edge, reconnectHandle)) {
-                this.tool.registerFeedback([
-                    HideEdgeReconnectHandlesFeedbackAction.create(),
-                    cursorFeedbackAction(CursorCSS.EDGE_RECONNECT),
-                    DrawFeedbackEdgeSourceAction.create({ elementTypeId: this.edge.type, targetId: this.edge.targetId })
-                ]);
+                this.editFeedback
+                    .add(cursorFeedbackAction(CursorCSS.EDGE_RECONNECT), cursorFeedbackAction())
+                    .add(
+                        DrawFeedbackEdgeSourceAction.create({ elementTypeId: this.edge.type, targetId: this.edge.targetId }),
+                        RemoveFeedbackEdgeAction.create()
+                    )
+                    .submit();
                 this.reconnectMode = 'NEW_SOURCE';
             } else if (isTargetRoutingHandle(edge, reconnectHandle)) {
-                this.tool.registerFeedback([
-                    HideEdgeReconnectHandlesFeedbackAction.create(),
-                    cursorFeedbackAction(CursorCSS.EDGE_CREATION_TARGET),
-                    DrawFeedbackEdgeAction.create({ elementTypeId: this.edge.type, sourceId: this.edge.sourceId })
-                ]);
+                this.editFeedback
+                    .add(cursorFeedbackAction(CursorCSS.EDGE_CREATION_TARGET), cursorFeedbackAction())
+                    .add(
+                        DrawFeedbackEdgeAction.create({ elementTypeId: this.edge.type, sourceId: this.edge.sourceId }),
+                        RemoveFeedbackEdgeAction.create()
+                    )
+                    .submit();
                 this.reconnectMode = 'NEW_TARGET';
             }
         }
@@ -204,22 +212,20 @@ export class EdgeEditListener extends DragAwareMouseListener implements ISelecti
                 this.setRoutingHandleSelected(edge, routingHandle);
             } else if (this.isValidEdge(edge)) {
                 // PHASE 1: Select edge
+                this.dispose();
                 this.tool.registerFeedbackListeners();
                 this.setEdgeSelected(edge);
             }
         } else if (event.button === 2) {
-            this.reset();
+            this.dispose();
         }
         return result;
     }
 
-    override mouseMove(target: GModelElement, event: MouseEvent): Action[] {
-        const result = super.mouseMove(target, event);
-        if (this.isMouseDrag) {
-            // reset any selected connectables when we are dragging, maybe the user is just panning
-            this.setNewConnectable(undefined);
-        }
-        return result;
+    protected override draggingMouseMove(target: GModelElement, event: MouseEvent): Action[] {
+        // reset any selected connectables when we are dragging, maybe the user is just panning
+        this.setNewConnectable(undefined);
+        return super.draggingMouseMove(target, event);
     }
 
     override mouseUp(target: GModelElement, event: MouseEvent): Action[] {
@@ -234,7 +240,7 @@ export class EdgeEditListener extends DragAwareMouseListener implements ISelecti
             if (this.requiresReconnect(sourceElementId, targetElementId)) {
                 result.push(ReconnectEdgeOperation.create({ edgeElementId: this.edge.id, sourceElementId, targetElementId }));
             }
-            this.reset();
+            this.dispose();
         } else if (this.edge && this.routingHandle) {
             // we need to re-retrieve the edge as it might have changed due to a server update since we do not reset the state between
             // reroute actions
@@ -258,11 +264,11 @@ export class EdgeEditListener extends DragAwareMouseListener implements ISelecti
                         (this.reconnectMode === 'NEW_SOURCE' && currentTarget.canConnect(this.edge, 'source')) ||
                         (this.reconnectMode === 'NEW_TARGET' && currentTarget.canConnect(this.edge, 'target'))
                     ) {
-                        this.tool.registerFeedback([cursorFeedbackAction(CursorCSS.EDGE_RECONNECT)]);
+                        this.editFeedback.add(cursorFeedbackAction(CursorCSS.EDGE_RECONNECT), cursorFeedbackAction()).submit();
                         return [];
                     }
                 }
-                this.tool.registerFeedback([cursorFeedbackAction(CursorCSS.OPERATION_NOT_ALLOWED)]);
+                this.editFeedback.add(cursorFeedbackAction(CursorCSS.OPERATION_NOT_ALLOWED), cursorFeedbackAction()).submit();
             }
         }
         return [];
@@ -292,30 +298,17 @@ export class EdgeEditListener extends DragAwareMouseListener implements ISelecti
                     }
                 }
             }
-
-            this.reset();
+            this.dispose();
         }
     }
 
-    public reset(): void {
-        this.resetFeedback();
-        this.resetData();
-    }
-
-    protected resetData(): void {
+    override dispose(): void {
         this.edge = undefined;
         this.reconnectMode = undefined;
         this.newConnectable = undefined;
         this.routingHandle = undefined;
-    }
-
-    protected resetFeedback(): void {
-        const result: Action[] = [];
-        if (this.edge) {
-            result.push(SwitchRoutingModeAction.create({ elementsToDeactivate: [this.edge.id] }));
-        }
-        result.push(...[HideEdgeReconnectHandlesFeedbackAction.create(), cursorFeedbackAction(), RemoveFeedbackEdgeAction.create()]);
-        this.tool.deregisterFeedback(undefined, result);
+        this.editFeedback.dispose();
         this.tool.deregisterFeedbackListeners();
+        super.dispose();
     }
 }

package/src/features/tools/marquee-selection/marquee-mouse-tool.ts

@@ -15,7 +15,6 @@
  ********************************************************************************/
 import {
     Action,
-    BoundsAware,
     DOMHelper,
     GModelElement,
     GModelRoot,
@@ -30,11 +29,12 @@ import { inject, injectable, optional } from 'inversify';
 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 { BoundsAwareModelElement, SelectableBoundsAware, isSelectableAndBoundsAware } from '../../../utils';
 import { getAbsolutePosition, toAbsoluteBounds } from '../../../utils/viewpoint-util';
 import { BaseEditTool } from '../base-tools';
 import { IMarqueeBehavior, MarqueeUtil } from './marquee-behavior';
 import { RemoveMarqueeAction } from './marquee-tool-feedback';
-import { GEdge } from '../../../model';
 
 @injectable()
 export class MarqueeMouseTool extends BaseEditTool {
@@ -53,7 +53,7 @@ export class MarqueeMouseTool extends BaseEditTool {
         this.toDisposeOnDisable.push(
             this.mouseTool.registerListener(new MarqueeMouseListener(this.domHelper, this.editorContext.modelRoot, this.marqueeBehavior)),
             this.keyTool.registerListener(this.shiftKeyListener),
-            this.registerFeedback([cursorFeedbackAction(CursorCSS.MARQUEE)], this, [cursorFeedbackAction()])
+            this.createFeedbackEmitter().add(cursorFeedbackAction(CursorCSS.MARQUEE), cursorFeedbackAction()).submit()
         );
     }
 }
@@ -61,7 +61,7 @@ export class MarqueeMouseTool extends BaseEditTool {
 export class MarqueeMouseListener extends DragAwareMouseListener {
     protected domHelper: DOMHelper;
     protected marqueeUtil: MarqueeUtil;
-    protected nodes: (GModelElement & BoundsAware)[];
+    protected nodes: BoundsAwareModelElement[];
     protected edges: SVGGElement[];
     protected previouslySelected: string[];
     protected isActive = false;
@@ -73,7 +73,7 @@ export class MarqueeMouseListener extends DragAwareMouseListener {
         this.nodes = Array.from(
             root.index
                 .all()
-                .map(e => e as GModelElement & BoundsAware)
+                .map(e => e as BoundsAwareModelElement)
                 .filter(e => isSelectable(e))
                 .filter(e => e instanceof GNode)
         );
@@ -94,7 +94,8 @@ export class MarqueeMouseListener extends DragAwareMouseListener {
             this.previouslySelected = Array.from(
                 target.root.index
                     .all()
-                    .map(e => e as GModelElement & BoundsAware)
+                    .filter(isSelectableAndBoundsAware)
+                    .map(e => e as SelectableBoundsAware)
                     .filter(e => isSelected(e))
                     .map(e => e.id)
             );