@eclipse-glsp/client 2.2.0-next.332 → 2.2.0-next.334

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

@@ -56,6 +56,10 @@ export class MarqueeMouseTool extends BaseEditTool {
             this.createFeedbackEmitter().add(cursorFeedbackAction(CursorCSS.MARQUEE), cursorFeedbackAction()).submit()
         );
     }
+
+    override get isEditTool(): boolean {
+        return false;
+    }
 }
 
 export class MarqueeMouseListener extends DragAwareMouseListener {

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

@@ -26,7 +26,7 @@ import {
     isCtrlOrCmd,
     isMoveable
 } from '@eclipse-glsp/sprotty';
-import { inject, injectable, optional } from 'inversify';
+import { inject, injectable } from 'inversify';
 import '../../../../css/ghost-element.css';
 import { FeedbackEmitter } from '../../../base';
 import { DragAwareMouseListener } from '../../../base/drag-aware-mouse-listener';
@@ -34,13 +34,12 @@ import { CSS_GHOST_ELEMENT, CSS_HIDDEN, CursorCSS, cursorFeedbackAction } from '
 import { EnableDefaultToolsAction } from '../../../base/tool-manager/tool';
 import { MoveableElement, isValidMove } from '../../../utils';
 import { getAbsolutePosition } from '../../../utils/viewpoint-util';
-import { IMovementRestrictor } from '../../change-bounds/movement-restrictor';
-import { PositionSnapper } from '../../change-bounds/position-snapper';
 import { RemoveTemplateElementsAction } from '../../element-template';
 import { AddTemplateElementsAction, getTemplateElementId } from '../../element-template/add-template-element';
 import { MouseTrackingElementPositionListener, PositioningTool } from '../../element-template/mouse-tracking-element-position-listener';
 import { Containable, isContainable } from '../../hints/model';
 import { BaseCreationTool } from '../base-tools';
+import { ChangeBoundsManager } from '../change-bounds';
 
 @injectable()
 export class NodeCreationTool extends BaseCreationTool<TriggerNodeCreationAction> implements PositioningTool {
@@ -48,8 +47,7 @@ export class NodeCreationTool extends BaseCreationTool<TriggerNodeCreationAction
 
     protected isTriggerAction = TriggerNodeCreationAction.is;
 
-    @inject(TYPES.IMovementRestrictor) @optional() readonly movementRestrictor?: IMovementRestrictor;
-    @inject(PositionSnapper) readonly positionSnapper: PositionSnapper;
+    @inject(TYPES.IChangeBoundsManager) readonly changeBoundsManager: ChangeBoundsManager;
 
     get id(): string {
         return NodeCreationTool.ID;
@@ -149,14 +147,16 @@ export class NodeCreationToolMouseListener extends DragAwareMouseListener {
     protected getValidInsertPosition(target: GModelElement, event: MouseEvent): Point | undefined {
         const ghostElement = this.getGhostElement();
         if (ghostElement) {
-            return isValidMove(ghostElement, ghostElement.position, this.tool.movementRestrictor) ? ghostElement.position : undefined;
+            return isValidMove(ghostElement, ghostElement.position, this.tool.changeBoundsManager.movementRestrictor)
+                ? ghostElement.position
+                : undefined;
         }
         const location = getAbsolutePosition(target, event);
 
         // Create a 0-bounds proxy element for snapping
         const elementProxy = new GNode();
         elementProxy.size = { width: 0, height: 0 };
-        return this.tool.positionSnapper.snapPosition(location, elementProxy);
+        return this.tool.changeBoundsManager.snapPosition(elementProxy, location);
     }
 
     override mouseOver(target: GModelElement, event: MouseEvent): Action[] {

package/src/features/viewport/viewport-handler.ts

@@ -1,5 +1,5 @@
 /********************************************************************************
- * Copyright (c) 2023 Business Informatics Group (TU Wien) and others.
+ * Copyright (c) 2023-2024 Business Informatics Group (TU Wien) 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,8 +13,9 @@
  *
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
-import { Action, IActionHandler, TYPES, ViewerOptions } from '@eclipse-glsp/sprotty';
+import { Action, DOMHelper, IActionHandler, TYPES } from '@eclipse-glsp/sprotty';
 import { inject, injectable } from 'inversify';
+import { EditorContextService } from '../../base';
 import { FocusTracker } from '../../base/focus/focus-tracker';
 import { IDiagramStartup } from '../../base/model/diagram-loader';
 import { EnableDefaultToolsAction } from '../../base/tool-manager/tool';
@@ -25,20 +26,26 @@ import { FocusDomAction } from '../accessibility/actions';
  */
 @injectable()
 export class RestoreViewportHandler implements IActionHandler, IDiagramStartup {
-    protected readonly graphSelector = '[data-svg-metadata-type="graph"]';
-
-    @inject(TYPES.ViewerOptions)
-    protected options: ViewerOptions;
+    @inject(TYPES.DOMHelper)
+    protected domHelper: DOMHelper;
 
     @inject(FocusTracker)
     protected focusTracker: FocusTracker;
 
+    @inject(EditorContextService)
+    protected editorContext: EditorContextService;
+
     handle(action: Action): void | Action {
         if (EnableDefaultToolsAction.is(action) || (FocusDomAction.is(action) && action.id === 'graph')) {
             this.focusGraph();
         }
     }
 
+    get graphSelector(): string {
+        const rootId = this.domHelper.createUniqueDOMElementId(this.editorContext.modelRoot);
+        return `#${rootId}`;
+    }
+
     async postRequestModel(): Promise<void> {
         await this.waitForElement(this.graphSelector);
         this.focusGraph();
@@ -51,7 +58,6 @@ export class RestoreViewportHandler implements IActionHandler, IDiagramStartup {
         }
     }
 
-    // https://stackoverflow.com/questions/5525071/how-to-wait-until-an-element-exists
     protected waitForElement(selector: string): Promise<Element | null> {
         return new Promise(resolve => {
             if (document.querySelector(selector)) {

package/src/utils/gmodel-util.ts

@@ -137,9 +137,12 @@ export function isNotUndefined<T>(element: T | undefined): element is T {
  * @param element The element to which the css classes should be added.
  * @param cssClasses The set of css classes as string array.
  */
-export function addCssClasses(element: GModelElement, cssClasses: string[]): void {
+export function addCssClasses(element: GModelElement, cssClasses: string[]): void;
+export function addCssClasses(element: GModelElement, ...cssClasses: string[]): void;
+export function addCssClasses(element: GModelElement, ...cssClasses: string[] | [string[]]): void {
+    const classes = Array.isArray(cssClasses[0]) ? cssClasses[0] : cssClasses;
     const elementCssClasses: string[] = element.cssClasses ?? [];
-    distinctAdd(elementCssClasses, ...cssClasses);
+    distinctAdd(elementCssClasses, ...classes);
     element.cssClasses = elementCssClasses;
 }
 
@@ -148,11 +151,44 @@ export function addCssClasses(element: GModelElement, cssClasses: string[]): voi
  * @param element The element from which the css classes should be removed.
  * @param cssClasses The set of css classes as string array.
  */
-export function removeCssClasses(root: GModelElement, cssClasses: string[]): void {
-    if (!root.cssClasses || root.cssClasses.length === 0) {
+export function removeCssClasses(element: GModelElement, cssClasses: string[]): void;
+export function removeCssClasses(element: GModelElement, ...cssClasses: string[]): void;
+export function removeCssClasses(element: GModelElement, ...cssClasses: string[] | [string[]]): void {
+    if (!element.cssClasses || element.cssClasses.length === 0) {
         return;
     }
-    remove(root.cssClasses, ...cssClasses);
+    const classes = Array.isArray(cssClasses[0]) ? cssClasses[0] : cssClasses;
+    remove(element.cssClasses, ...classes);
+}
+
+/**
+ * Adds a css classs to a set of {@link GModelElement}s.
+ *
+ * @param elements The elements to which the css class should be added.
+ * @param cssClass The css class to add.
+ */
+export function addCssClassToElements(elements: GModelElement[], ...cssClasses: string[]): void {
+    for (const element of elements) {
+        addCssClasses(element, cssClasses);
+    }
+}
+
+/**
+ * Removes a css class from a set of {@link GModelElement}s.
+ * @param elements The elements from which the css class should be removed.
+ * @param cssClass The css class to remove.
+ */
+export function removeCssClassOfElements(elements: GModelElement[], ...cssClasses: string[]): void {
+    for (const element of elements) {
+        removeCssClasses(element, cssClasses);
+    }
+}
+
+/**
+ * Toggles a css class on a {@link GModelElement} based on the given toggle flag.
+ */
+export function toggleCssClass(element: GModelElement, cssClass: string, toggle: boolean): void {
+    return toggle ? addCssClasses(element, cssClass) : removeCssClasses(element, cssClass);
 }
 
 export function isNonRoutableSelectedMovableBoundsAware(element: GModelElement): element is SelectableBoundsAware {

package/src/utils/layout-utils.ts

@@ -33,6 +33,10 @@ export function minHeight(element: BoundsAwareModelElement): number {
     return 1;
 }
 
+export function minDimensions(element: BoundsAwareModelElement): Dimension {
+    return { width: minWidth(element), height: minHeight(element) };
+}
+
 export function getLayoutOptions(element: GModelElement): ModelLayoutOptions | undefined {
     const layoutOptions = (element as any).layoutOptions;
     if (layoutOptions !== undefined) {