@eclipse-glsp/client 0.10.0-next.e5fcffe.169 → 1.1.0-next.26c3266.182

package/src/features/validation/marker-navigator.ts

@@ -16,12 +16,10 @@
 import { Action, CenterAction, hasArrayProp, hasStringProp, Point, SelectAction } from '@eclipse-glsp/protocol';
 import { inject, injectable } from 'inversify';
 import {
+    ActionDispatcher,
     BoundsAware,
-    CenterCommand,
-    Command,
-    CommandExecutionContext,
-    CommandReturn,
     findParentByFeature,
+    IActionHandler,
     IContextMenuItemProvider,
     isBoundsAware,
     isSelectable,
@@ -36,8 +34,8 @@ import {
 import { matchesKeystroke } from 'sprotty/lib/utils/keyboard';
 import { TYPES } from '../../base/types';
 import { collectIssueMarkers, MarkerPredicates } from '../../utils/marker';
-import { isSelectableAndBoundsAware } from '../../utils/smodel-util';
-import { SelectCommand, SelectionService } from '../select/selection-service';
+import { getElements, isSelectableAndBoundsAware } from '../../utils/smodel-util';
+import { SelectionService } from '../select/selection-service';
 
 export interface NavigateToMarkerAction extends Action {
     kind: typeof NavigateToMarkerAction.KIND;
@@ -106,7 +104,7 @@ export class MarkerNavigator {
     protected markerComparator: SModelElementComparator;
 
     next(
-        root: SModelRoot,
+        root: Readonly<SModelRoot>,
         current?: SModelElement & BoundsAware,
         predicate: (marker: SIssueMarker) => boolean = MarkerPredicates.ALL
     ): SIssueMarker | undefined {
@@ -118,7 +116,7 @@ export class MarkerNavigator {
     }
 
     previous(
-        root: SModelRoot,
+        root: Readonly<SModelRoot>,
         current?: SModelElement & BoundsAware,
         predicate: (marker: SIssueMarker) => boolean = MarkerPredicates.ALL
     ): SIssueMarker | undefined {
@@ -129,7 +127,7 @@ export class MarkerNavigator {
         return markers[this.getPreviousIndex(current, markers) % markers.length];
     }
 
-    protected getMarkers(root: SModelRoot, predicate: (marker: SIssueMarker) => boolean): SIssueMarker[] {
+    protected getMarkers(root: Readonly<SModelRoot>, predicate: (marker: SIssueMarker) => boolean): SIssueMarker[] {
         const markers = collectIssueMarkers(root);
         return markers.filter(predicate).sort(this.markerComparator.compare);
     }
@@ -154,9 +152,7 @@ export class MarkerNavigator {
 }
 
 @injectable()
-export class NavigateToMarkerCommand extends Command {
-    static KIND = NavigateToMarkerAction.KIND;
-
+export class NavigateToMarkerActionHandler implements IActionHandler {
     @inject(SModelElementComparator)
     protected markerComparator: SModelElementComparator;
 
@@ -166,73 +162,40 @@ export class NavigateToMarkerCommand extends Command {
     @inject(TYPES.SelectionService)
     protected selectionService: SelectionService;
 
-    protected selectCommand: SelectCommand;
-    protected centerCommand: CenterCommand;
-
-    constructor(@inject(TYPES.Action) protected action: NavigateToMarkerAction) {
-        super();
-    }
+    @inject(TYPES.IActionDispatcher)
+    protected actionDispatcher: ActionDispatcher;
 
-    execute(context: CommandExecutionContext): CommandReturn {
-        const root = context.root;
-        const selected = this.getSelectedElements(root);
-        const target = this.getTarget(selected, root);
-        if (target === undefined) {
-            return root;
-        }
+    handle(action: NavigateToMarkerAction): void {
+        const selected = this.getSelectedElements(action);
+        const target = this.getTarget(action, selected);
 
-        const selectableTarget = findParentByFeature(target, isSelectable);
+        const selectableTarget = target ? findParentByFeature(target, isSelectable) : undefined;
         if (selectableTarget) {
-            const deselect = selected.map(e => e.id).filter(id => id !== selectableTarget.id);
-            this.selectCommand = new SelectCommand(
-                SelectAction.create({ selectedElementsIDs: [selectableTarget.id], deselectedElementsIDs: deselect }),
-                this.selectionService
-            );
-            this.centerCommand = new CenterCommand(CenterAction.create([selectableTarget.id]));
-            this.centerCommand.execute(context);
-            return this.selectCommand.execute(context);
+            const deselectedElementsIDs = selected.map(e => e.id).filter(id => id !== selectableTarget.id);
+            this.actionDispatcher.dispatch(SelectAction.create({ selectedElementsIDs: [selectableTarget.id], deselectedElementsIDs }));
+            this.actionDispatcher.dispatch(CenterAction.create([selectableTarget.id]));
         }
-        return root;
     }
 
-    protected getSelectedElements(root: SModelRoot): (SModelElement & Selectable)[] {
-        let selectedIds = [];
-        if (this.action.selectedElementIds !== undefined && this.action.selectedElementIds.length > 0) {
-            selectedIds = this.action.selectedElementIds;
-        } else {
-            return this.selectionService.getSelectedElements();
+    protected getSelectedElements(action: NavigateToMarkerAction): (SModelElement & Selectable)[] {
+        if (action.selectedElementIds && action.selectedElementIds.length > 0) {
+            return getElements(this.selectionService.getModelRoot().index, action.selectedElementIds, isSelectable);
         }
-        return selectedIds.map(id => root.index.getById(id)).filter(element => element !== undefined && isSelectable(element)) as Array<
-            SModelElement & Selectable
-        >;
+        return this.selectionService.getSelectedElements();
     }
 
-    protected getTarget(selected: SModelElement[], root: SModelRoot): SIssueMarker | undefined {
-        const selectedBoundsAware = selected.filter(isBoundsAware).sort(this.markerComparator.compare);
-        const currentTopmost = selectedBoundsAware.length > 0 ? selectedBoundsAware[0] : undefined;
-        if (this.action.direction === 'previous') {
-            return this.markerNavigator.previous(root, currentTopmost, marker => this.matchesSeverities(marker));
+    protected getTarget(action: NavigateToMarkerAction, selected: SModelElement[]): SIssueMarker | undefined {
+        const root = this.selectionService.getModelRoot();
+        const target = selected.sort(this.markerComparator.compare).find(isBoundsAware);
+        if (action.direction === 'previous') {
+            return this.markerNavigator.previous(root, target, marker => this.matchesSeverities(action, marker));
         } else {
-            return this.markerNavigator.next(root, currentTopmost, marker => this.matchesSeverities(marker));
+            return this.markerNavigator.next(root, target, marker => this.matchesSeverities(action, marker));
         }
     }
 
-    protected matchesSeverities(marker: SIssueMarker): boolean {
-        return marker.issues.find(issue => this.action.severities.includes(issue.severity)) !== undefined;
-    }
-
-    undo(context: CommandExecutionContext): CommandReturn {
-        if (this.selectCommand) {
-            context.root = this.selectCommand.undo(context);
-        }
-        return this.centerCommand ? this.centerCommand.undo(context) : context.root;
-    }
-
-    redo(context: CommandExecutionContext): CommandReturn {
-        if (this.selectCommand) {
-            context.root = this.selectCommand.redo(context);
-        }
-        return this.centerCommand ? this.centerCommand.redo(context) : context.root;
+    protected matchesSeverities(action: NavigateToMarkerAction, marker: SIssueMarker): boolean {
+        return marker.issues.find(issue => action.severities.includes(issue.severity)) !== undefined;
     }
 }
 

package/src/features/validation/validate.ts

@@ -15,24 +15,14 @@
  ********************************************************************************/
 import { Action, DeleteMarkersAction, hasArrayProp, Marker, SetMarkersAction } from '@eclipse-glsp/protocol';
 import { inject, injectable, optional } from 'inversify';
-import {
-    Command,
-    CommandExecutionContext,
-    CommandReturn,
-    IActionDispatcher,
-    SIssue,
-    SIssueMarker,
-    SModelElement,
-    SModelRoot,
-    SParentElement
-} from 'sprotty';
+import { CommandExecutionContext, CommandReturn, IActionDispatcher, IActionHandler, ICommand, SIssueMarker, SParentElement } from 'sprotty';
 import { EditorContextService } from '../../base/editor-context-service';
 import { TYPES } from '../../base/types';
 import { removeCssClasses } from '../../utils/smodel-util';
 import { getSeverity } from '../hover/hover';
 import { IFeedbackActionDispatcher, IFeedbackEmitter } from '../tool-feedback/feedback-action-dispatcher';
 import { FeedbackCommand } from '../tool-feedback/model';
-import { createSIssue, getOrCreateSIssueMarker, getSIssueMarker } from './issue-marker';
+import { createSIssue, getOrCreateSIssueMarker, getSIssueMarker, GIssueMarker } from './issue-marker';
 
 /**
  * Feedback emitter sending actions for visualizing model validation feedback and
@@ -94,43 +84,33 @@ export abstract class ExternalMarkerManager {
     abstract setMarkers(markers: Marker[], sourceUri?: string): void;
 }
 
-/**
- * Command for handling `SetMarkersAction`
- */
 @injectable()
-export class SetMarkersCommand extends Command {
-    @inject(ValidationFeedbackEmitter) protected validationFeedbackEmitter: ValidationFeedbackEmitter;
-    @inject(ExternalMarkerManager) @optional() protected externalMarkerManager?: ExternalMarkerManager;
-    @inject(EditorContextService) protected editorContextService: EditorContextService;
+export class SetMarkersActionHandler implements IActionHandler {
+    @inject(ValidationFeedbackEmitter)
+    protected validationFeedbackEmitter: ValidationFeedbackEmitter;
 
-    static readonly KIND = SetMarkersAction.KIND;
+    @inject(ExternalMarkerManager)
+    @optional()
+    protected externalMarkerManager?: ExternalMarkerManager;
 
-    constructor(@inject(TYPES.Action) public action: SetMarkersAction) {
-        super();
+    @inject(EditorContextService)
+    protected editorContextService: EditorContextService;
+
+    handle(action: SetMarkersAction): void | Action | ICommand {
+        const markers: Marker[] = action.markers;
+        this.setMarkers(markers);
     }
 
-    async execute(context: CommandExecutionContext): Promise<SModelRoot> {
-        const markers: Marker[] = this.action.markers;
+    async setMarkers(markers: Marker[]): Promise<void> {
         const uri = await this.editorContextService.getSourceUri();
-        if (this.externalMarkerManager) {
-            this.externalMarkerManager.setMarkers(markers, uri);
-        }
+        this.externalMarkerManager?.setMarkers(markers, uri);
         const applyMarkersAction = ApplyMarkersAction.create(markers);
         this.validationFeedbackEmitter.registerValidationFeedbackAction(applyMarkersAction);
-        return context.root;
-    }
-
-    undo(context: CommandExecutionContext): CommandReturn {
-        return context.root;
-    }
-
-    redo(context: CommandExecutionContext): CommandReturn {
-        return this.execute(context);
     }
 }
 
 /**
- * Action for applying makers to a model
+ * Action for applying makers to the graphical model.
  */
 export interface ApplyMarkersAction extends Action {
     kind: typeof ApplyMarkersAction.KIND;
@@ -153,43 +133,36 @@ export namespace ApplyMarkersAction {
 }
 
 /**
- * Command for handling `ApplyMarkersAction`
+ * Handles {@link ApplyMarkersAction}s by creating the corresponding {@link SIssueMarker}s and
+ * adding them to the graphical model.
  */
 @injectable()
 export class ApplyMarkersCommand extends FeedbackCommand {
     static KIND = ApplyMarkersAction.KIND;
-    override readonly priority = 0;
 
     constructor(@inject(TYPES.Action) protected action: ApplyMarkersAction) {
         super();
     }
 
     execute(context: CommandExecutionContext): CommandReturn {
-        const markers: Marker[] = this.action.markers;
-        for (const marker of markers) {
-            const modelElement: SModelElement | undefined = context.root.index.getById(marker.elementId);
+        this.action.markers.forEach(marker => {
+            const modelElement = context.root.index.getById(marker.elementId);
             if (modelElement instanceof SParentElement) {
-                const issueMarker: SIssueMarker = getOrCreateSIssueMarker(modelElement);
-                const issue: SIssue = createSIssue(marker);
+                const issueMarker = getOrCreateSIssueMarker(modelElement);
+                const issue = createSIssue(marker);
                 issueMarker.issues.push(issue);
+                if (issueMarker instanceof GIssueMarker) {
+                    issueMarker.computeProjectionCssClasses();
+                }
                 addMaxSeverityCSSClassToIssueParent(modelElement, issueMarker);
             }
-        }
-        return context.root;
-    }
-
-    override undo(context: CommandExecutionContext): CommandReturn {
+        });
         return context.root;
     }
-
-    override redo(context: CommandExecutionContext): CommandReturn {
-        return this.execute(context);
-    }
 }
 
 function addMaxSeverityCSSClassToIssueParent(modelElement: SParentElement, issueMarker: SIssueMarker): void {
     const maxSeverityCSSClass = getSeverity(issueMarker);
-
     if (!modelElement.cssClasses) {
         modelElement.cssClasses = [maxSeverityCSSClass];
     } else {
@@ -199,14 +172,15 @@ function addMaxSeverityCSSClassToIssueParent(modelElement: SParentElement, issue
 }
 
 function removeCSSClassFromIssueParent(modelElement: SParentElement, issueMarker: SIssueMarker): void {
-    removeCssClasses(modelElement, [getSeverity(issueMarker)]);
+    const severity = getSeverity(issueMarker);
+    removeCssClasses(modelElement, [severity]);
 }
 
 /**
  * Command for handling `DeleteMarkersAction`
  */
 @injectable()
-export class DeleteMarkersCommand extends Command {
+export class DeleteMarkersCommand extends FeedbackCommand {
     static KIND = DeleteMarkersAction.KIND;
 
     constructor(@inject(TYPES.Action) protected action: DeleteMarkersAction) {
@@ -214,15 +188,14 @@ export class DeleteMarkersCommand extends Command {
     }
 
     execute(context: CommandExecutionContext): CommandReturn {
-        const markers: Marker[] = this.action.markers;
-        for (const marker of markers) {
-            const modelElement: SModelElement | undefined = context.root.index.getById(marker.elementId);
+        this.action.markers.forEach(marker => {
+            const modelElement = context.root.index.getById(marker.elementId);
             if (modelElement instanceof SParentElement) {
-                const issueMarker: SIssueMarker | undefined = getSIssueMarker(modelElement);
-                if (issueMarker !== undefined) {
+                const issueMarker = getSIssueMarker(modelElement);
+                if (issueMarker) {
                     removeCSSClassFromIssueParent(modelElement, issueMarker);
                     for (let index = 0; index < issueMarker.issues.length; ++index) {
-                        const issue: SIssue = issueMarker.issues[index];
+                        const issue = issueMarker.issues[index];
                         if (issue.message === marker.description) {
                             issueMarker.issues.splice(index--, 1);
                         }
@@ -234,15 +207,8 @@ export class DeleteMarkersCommand extends Command {
                     }
                 }
             }
-        }
-        return context.root;
-    }
+        });
 
-    undo(context: CommandExecutionContext): CommandReturn {
         return context.root;
     }
-
-    redo(context: CommandExecutionContext): CommandReturn {
-        return this.execute(context);
-    }
 }

package/src/index.ts

@@ -21,15 +21,15 @@ import glspDecorationModule from './features/decoration/di.config';
 import glspEditLabelModule from './features/edit-label/di.config';
 import modelHintsModule from './features/hints/di.config';
 import glspHoverModule from './features/hover/di.config';
-import layoutCommandsModule from './features/layout/di.config';
-import modelSourceWatcherModule from './features/model-source-watcher/di.config';
+import layoutModule from './features/layout/di.config';
 import glspMouseToolModule from './features/mouse-tool/di.config';
 import { navigationModule } from './features/navigation/di.config';
 import saveModule from './features/save/di.config';
 import glspSelectModule from './features/select/di.config';
+import sourceModelWatcherModule from './features/source-model-watcher/di.config';
 import toolFeedbackModule from './features/tool-feedback/di.config';
 import paletteModule from './features/tool-palette/di.config';
-import toolsModule from './features/tools/di.config';
+import { enableDefaultToolsOnFocusLossModule, toolsModule } from './features/tools/di.config';
 import { markerNavigatorModule, validationModule } from './features/validation/di.config';
 import glspViewportModule from './features/viewport/di.config';
 
@@ -65,8 +65,7 @@ export * from './features/edit-label/edit-label-validator';
 export * from './features/hints/model';
 export * from './features/hints/type-hints';
 export * from './features/hover/hover';
-export * from './features/layout/layout-commands';
-export * from './features/model-source-watcher/model-source-changed-action-handler';
+export * from './features/layout/layout-elements-action';
 export * from './features/mouse-tool/mouse-tool';
 export * from './features/navigation/navigation-action-handler';
 export * from './features/navigation/navigation-target-resolver';
@@ -74,6 +73,7 @@ export * from './features/rank/model';
 export * from './features/reconnect/model';
 export * from './features/save/model';
 export * from './features/save/save-keylistener';
+export * from './features/source-model-watcher/source-model-changed-action-handler';
 export * from './features/tool-feedback/change-bounds-tool-feedback';
 export * from './features/tool-feedback/creation-tool-feedback';
 export * from './features/tool-feedback/css-feedback';
@@ -113,13 +113,14 @@ export {
     copyPasteContextMenuModule,
     glspSelectModule,
     glspMouseToolModule,
-    layoutCommandsModule,
+    layoutModule,
     glspEditLabelModule,
     glspHoverModule,
     toolsModule,
+    enableDefaultToolsOnFocusLossModule,
     navigationModule,
     markerNavigatorModule,
     glspDecorationModule,
-    modelSourceWatcherModule,
+    sourceModelWatcherModule as modelSourceWatcherModule,
     glspViewportModule
 };

package/src/lib/model.ts

@@ -14,7 +14,7 @@
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
 import { SModelElementSchema } from '@eclipse-glsp/protocol';
-import { exportFeature, SGraph, SModelElement, viewportFeature } from 'sprotty/lib';
+import { exportFeature, SGraph, SModelElement, viewportFeature } from 'sprotty';
 import { Containable, containerFeature } from '../features/hints/model';
 import { Saveable, saveFeature } from '../features/save/model';
 

package/src/model-source/glsp-diagram-server.ts

@@ -90,7 +90,7 @@ export class GLSPDiagramServer extends DiagramServerProxy implements SourceUriAw
         return !isReceivedFromServer(action);
     }
 
-    public getSourceURI(): string {
+    public get sourceURI(): string {
         return this._sourceUri;
     }
 }

package/src/utils/layout-utils.ts

@@ -13,7 +13,7 @@
  *
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
-import { Dimension, ElementAndBounds, Point } from '@eclipse-glsp/protocol';
+import { Dimension, ElementAndBounds, Point, Writable } from '@eclipse-glsp/protocol';
 import { BoundsAware, ElementMove, ModelLayoutOptions, SModelElement } from 'sprotty';
 import { IMovementRestrictor } from '../features/change-bounds/movement-restrictor';
 
@@ -45,18 +45,18 @@ export function isValidSize(element: SModelElement & BoundsAware, size: Dimensio
     return size.width >= minWidth(element) && size.height >= minHeight(element);
 }
 
-export function isValidMove(element: SModelElement & BoundsAware, newPosition: Point, movementRestrictor?: IMovementRestrictor): boolean {
+export function isValidMove(element: SModelElement & BoundsAware, newPosition?: Point, movementRestrictor?: IMovementRestrictor): boolean {
     if (movementRestrictor) {
-        return movementRestrictor.validate(newPosition, element);
+        return movementRestrictor.validate(element, newPosition);
     }
     return true;
 }
 
 export function toValidElementMove(
     element: SModelElement & BoundsAware,
-    move: WriteableElementMove,
+    move: ElementMove,
     movementRestrictor?: IMovementRestrictor
-): WriteableElementMove | undefined {
+): ElementMove | undefined {
     if (!isValidMove(element, move.toPosition, movementRestrictor)) {
         return;
     }
@@ -65,9 +65,9 @@ export function toValidElementMove(
 
 export function toValidElementAndBounds(
     element: SModelElement & BoundsAware,
-    bounds: WriteableElementAndBounds,
+    bounds: Writable<ElementAndBounds>,
     movementRestrictor?: IMovementRestrictor
-): WriteableElementAndBounds | undefined {
+): ElementAndBounds | undefined {
     if (!isValidMove(element, bounds.newPosition, movementRestrictor)) {
         return;
     }
@@ -81,23 +81,3 @@ export function toValidElementAndBounds(
     }
     return bounds;
 }
-
-export interface WriteablePoint extends Point {
-    x: number;
-    y: number;
-}
-
-export interface WriteableElementMove extends ElementMove {
-    fromPosition?: WriteablePoint;
-    toPosition: WriteablePoint;
-}
-
-export interface WriteableDimension extends Dimension {
-    width: number;
-    height: number;
-}
-
-export interface WriteableElementAndBounds extends ElementAndBounds {
-    newPosition: WriteablePoint;
-    newSize: WriteableDimension;
-}

package/src/views/base-view-module.ts

@@ -26,6 +26,7 @@ import {
     ForeignObjectView,
     HtmlRoot,
     HtmlRootView,
+    moveFeature,
     PreRenderedElement,
     PreRenderedView,
     RectangularNode,
@@ -34,6 +35,7 @@ import {
     SCompartment,
     SCompartmentView,
     SEdge,
+    selectFeature,
     SGraphView,
     ShapedPreRenderedElement,
     SIssueMarker,
@@ -66,7 +68,9 @@ export function configureDefaultModelElements(context: ContainerContext): void {
     configureModelElement(context, DefaultTypes.HTML, HtmlRoot, HtmlRootView);
 
     // generic elements
-    configureModelElement(context, DefaultTypes.FOREIGN_OBJECT, ForeignObjectElement, ForeignObjectView);
+    configureModelElement(context, DefaultTypes.FOREIGN_OBJECT, ForeignObjectElement, ForeignObjectView, {
+        disable: [selectFeature, moveFeature]
+    });
     configureModelElement(context, DefaultTypes.PRE_RENDERED, PreRenderedElement, PreRenderedView);
     configureModelElement(context, DefaultTypes.SHAPE_PRE_RENDERED, ShapedPreRenderedElement, PreRenderedView);