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

package/src/features/hover/di.config.ts

@@ -1,5 +1,5 @@
 /********************************************************************************
- * Copyright (c) 2020-2021 EclipseSource and others.
+ * Copyright (c) 2020-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
@@ -19,6 +19,8 @@ import {
     ClosePopupActionHandler,
     configureActionHandler,
     configureCommand,
+    EnableDefaultToolsAction,
+    EnableToolsAction,
     FitToScreenCommand,
     HoverFeedbackCommand,
     HoverKeyListener,
@@ -35,7 +37,8 @@ import { GlspHoverMouseListener } from './hover';
 
 const glspHoverModule = new ContainerModule((bind, _unbind, isBound) => {
     bind(TYPES.PopupVNodePostprocessor).to(PopupPositionUpdater).inSingletonScope();
-    bind(TYPES.MouseListener).to(GlspHoverMouseListener);
+    bind(GlspHoverMouseListener).toSelf().inSingletonScope();
+    bind(TYPES.MouseListener).toService(GlspHoverMouseListener);
     bind(TYPES.PopupMouseListener).to(PopupHoverMouseListener);
     bind(TYPES.KeyListener).to(HoverKeyListener);
     bind<HoverState>(TYPES.HoverState).toConstantValue({
@@ -55,6 +58,9 @@ const glspHoverModule = new ContainerModule((bind, _unbind, isBound) => {
     configureActionHandler(context, SetViewportCommand.KIND, ClosePopupActionHandler);
     configureActionHandler(context, MoveCommand.KIND, ClosePopupActionHandler);
     configureActionHandler(context, FocusStateChangedAction.KIND, ClosePopupActionHandler);
+    configureActionHandler(context, EnableToolsAction.KIND, GlspHoverMouseListener);
+    configureActionHandler(context, EnableDefaultToolsAction.KIND, GlspHoverMouseListener);
+    configureActionHandler(context, FocusStateChangedAction.KIND, GlspHoverMouseListener);
 });
 
 export default glspHoverModule;

package/src/features/hover/hover.ts

@@ -1,5 +1,5 @@
 /********************************************************************************
- * Copyright (c) 2020-2021 EclipseSource and others.
+ * Copyright (c) 2020-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,31 +13,64 @@
  *
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
-import { Action, Bounds, RequestPopupModelAction, SetPopupModelAction } from '@eclipse-glsp/protocol';
-import { injectable } from 'inversify';
 import {
-    EMPTY_ROOT,
-    HoverMouseListener,
+    Action,
+    Bounds,
     PreRenderedElementSchema,
-    SIssueMarker,
-    SIssueSeverity,
-    SModelElement,
+    RequestPopupModelAction,
+    SetPopupModelAction,
     SModelElementSchema,
     SModelRootSchema
-} from 'sprotty';
-import { GIssueMarker } from '../validation/issue-marker';
-
+} from '@eclipse-glsp/protocol';
+import { injectable } from 'inversify';
+import { EMPTY_ROOT, HoverFeedbackAction, HoverMouseListener, IActionHandler, ICommand, SModelElement } from 'sprotty';
+import { FocusStateChangedAction } from '../../base/actions/focus-change-action';
+import { EnableDefaultToolsAction, EnableToolsAction } from '../../base/tool-manager/tool-actions';
+import { EdgeCreationTool } from '../tools/edge-creation-tool';
+import { getSeverity, GIssueMarker } from '../validation/issue-marker';
 @injectable()
-export class GlspHoverMouseListener extends HoverMouseListener {
-    protected startMouseOverTimer(target: SModelElement, event: MouseEvent): Promise<Action> {
+export class GlspHoverMouseListener extends HoverMouseListener implements IActionHandler {
+    protected enableHover = true;
+    /**
+     * Stops mouse over timer and remove hover feedback, if focus is lost.
+     *
+     * This fixes strange effects that appear if the mouse left the element via e.g. a context menu,
+     * which explicitly removes the focus of the diagram.
+     * @see SelectionServiceAwareContextMenuMouseListener
+     * @param action should be a `FocusStateChangedAction`
+     * @returns a `HoverFeedbackAction` resetting the state, if the specified action indicates lost focus
+     */
+    handle(action: Action): void | Action | ICommand {
+        if (FocusStateChangedAction.is(action) && !action.hasFocus) {
+            this.stopMouseOverTimer();
+            if (this.lastHoverFeedbackElementId) {
+                const previousTargetId = this.lastHoverFeedbackElementId;
+                this.lastHoverFeedbackElementId = undefined;
+                return HoverFeedbackAction.create({ mouseoverElement: previousTargetId, mouseIsOver: false });
+            }
+        } else if (EnableToolsAction.is(action)) {
+            this.enableHover = !(action as EnableToolsAction).toolIds.includes(EdgeCreationTool.ID);
+        } else if (EnableDefaultToolsAction.is(action)) {
+            this.enableHover = true;
+        }
+    }
+
+    override mouseOver(target: SModelElement, event: MouseEvent): (Action | Promise<Action>)[] {
+        if (this.enableHover) {
+            return super.mouseOver(target, event);
+        }
+        return [];
+    }
+
+    protected override startMouseOverTimer(target: SModelElement, event: MouseEvent): Promise<Action> {
         this.stopMouseOverTimer();
         return new Promise(resolve => {
             this.state.mouseOverTimer = window.setTimeout(() => {
                 const popupBounds = this.computePopupBounds(target, { x: event.pageX, y: event.pageY });
                 if (target instanceof GIssueMarker) {
-                    resolve(new SetPopupModelAction(this.createPopupModel(target as GIssueMarker, popupBounds)));
+                    resolve(SetPopupModelAction.create(this.createPopupModel(target as GIssueMarker, popupBounds)));
                 } else {
-                    resolve(new RequestPopupModelAction(target.id, popupBounds));
+                    resolve(RequestPopupModelAction.create({ elementId: target.id, bounds: popupBounds }));
                 }
 
                 this.state.popupOpen = true;
@@ -75,16 +108,3 @@ export class GlspHoverMouseListener extends HoverMouseListener {
         return bounds;
     }
 }
-
-export function getSeverity(marker: SIssueMarker): SIssueSeverity {
-    let currentSeverity: SIssueSeverity = 'info';
-    for (const severity of marker.issues.map(s => s.severity)) {
-        if (severity === 'error') {
-            return severity;
-        }
-        if (severity === 'warning' && currentSeverity === 'info') {
-            currentSeverity = severity;
-        }
-    }
-    return currentSeverity;
-}

package/src/features/layout/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,17 +14,27 @@
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
 import { ContainerModule } from 'inversify';
-import { configureCommand, configureLayout, VBoxLayouter } from 'sprotty';
+import { configureActionHandler, configureLayout, HBoxLayouter, TYPES, VBoxLayouter } from 'sprotty';
 import { FreeFormLayouter } from './freeform-layout';
-import { AlignElementsCommand, ResizeElementsCommand } from './layout-commands';
+import { HBoxLayouterExt } from './hbox-layout';
+import {
+    AlignElementsAction,
+    AlignElementsActionHandler,
+    ResizeElementsAction,
+    ResizeElementsActionHandler
+} from './layout-elements-action';
+import { LayouterExt } from './layouter';
 import { VBoxLayouterExt } from './vbox-layout';
 
-const layoutCommandsModule = new ContainerModule((bind, _unbind, isBound, rebind) => {
-    configureCommand({ bind, isBound }, ResizeElementsCommand);
-    configureCommand({ bind, isBound }, AlignElementsCommand);
+const layoutModule = new ContainerModule((bind, _unbind, isBound, rebind) => {
+    const context = { bind, isBound };
+    configureActionHandler(context, ResizeElementsAction.KIND, ResizeElementsActionHandler);
+    configureActionHandler(context, AlignElementsAction.KIND, AlignElementsActionHandler);
 
     rebind(VBoxLayouter).to(VBoxLayouterExt);
+    rebind(HBoxLayouter).to(HBoxLayouterExt);
+    rebind(TYPES.Layouter).to(LayouterExt);
     configureLayout({ bind, isBound }, FreeFormLayouter.KIND, FreeFormLayouter);
 });
 
-export default layoutCommandsModule;
+export default layoutModule;

package/src/features/layout/freeform-layout.ts

@@ -1,5 +1,5 @@
 /********************************************************************************
- * Copyright (c) 2021 EclipseSource and others.
+ * Copyright (c) 2021-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,18 +13,9 @@
  *
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
+import { Bounds, Dimension, Point } from '@eclipse-glsp/protocol';
 import { injectable } from 'inversify';
-import {
-    Bounds,
-    BoundsData,
-    Dimension,
-    isValidDimension,
-    LayoutContainer,
-    Point,
-    SChildElement,
-    SParentElement,
-    StatefulLayouter
-} from 'sprotty';
+import { BoundsData, LayoutContainer, SChildElement, SParentElement, StatefulLayouter } from 'sprotty';
 import { AbstractLayout } from 'sprotty/lib/features/bounds/abstract-layout';
 import { AbstractLayoutOptions } from 'sprotty/lib/features/bounds/layout-options';
 
@@ -35,7 +26,7 @@ import { AbstractLayoutOptions } from 'sprotty/lib/features/bounds/layout-option
 export class FreeFormLayouter extends AbstractLayout<AbstractLayoutOptions> {
     static KIND = 'freeform';
 
-    layout(container: SParentElement & LayoutContainer, layouter: StatefulLayouter): void {
+    override layout(container: SParentElement & LayoutContainer, layouter: StatefulLayouter): void {
         const boundsData = layouter.getBoundsData(container);
         const options = this.getLayoutOptions(container);
         const childrenSize = this.getChildrenSize(container, options, layouter);
@@ -64,7 +55,7 @@ export class FreeFormLayouter extends AbstractLayout<AbstractLayoutOptions> {
         let maxY = 0;
         container.children.forEach(child => {
             const bounds = layouter.getBoundsData(child).bounds;
-            if (bounds !== undefined && isValidDimension(bounds)) {
+            if (bounds !== undefined && Dimension.isValid(bounds)) {
                 const childMaxX = bounds.x + bounds.width;
                 const childMaxY = bounds.y + bounds.height;
                 maxX = Math.max(maxX, childMaxX);
@@ -97,7 +88,7 @@ export class FreeFormLayouter extends AbstractLayout<AbstractLayoutOptions> {
         return currentOffset;
     }
 
-    protected getFinalContainerBounds(
+    protected override getFinalContainerBounds(
         container: SParentElement & LayoutContainer,
         lastOffset: Point,
         options: AbstractLayoutOptions,

package/src/features/layout/hbox-layout.ts

@@ -0,0 +1,273 @@
+/********************************************************************************
+ * Copyright (c) 2021-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
+ * 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 { Bounds, Dimension, Point } from '@eclipse-glsp/protocol';
+import { injectable } from 'inversify';
+import {
+    BoundsData,
+    isBoundsAware,
+    isLayoutableChild,
+    LayoutContainer,
+    SChildElement,
+    SModelElement,
+    SParentElement,
+    StatefulLayouter,
+    HBoxLayouter,
+    HBoxLayoutOptions
+} from 'sprotty';
+
+export interface HBoxLayoutOptionsExt extends HBoxLayoutOptions {
+    hGrab: boolean;
+    vGrab: boolean;
+    prefWidth: number | null;
+    prefHeight: number | null;
+}
+
+/**
+ * Extends HBoxLayouter to support additional layout options
+ */
+@injectable()
+export class HBoxLayouterExt extends HBoxLayouter {
+    static override KIND = HBoxLayouter.KIND;
+
+    override layout(container: SParentElement & LayoutContainer, layouter: StatefulLayouter): void {
+        const boundsData = layouter.getBoundsData(container);
+        const options = this.getLayoutOptions(container);
+        const childrenSize = this.getChildrenSize(container, options, layouter);
+
+        const fixedSize = this.getFixedContainerBounds(container, options, layouter);
+
+        const currentWidth = boundsData.bounds ? boundsData.bounds?.width - options.paddingLeft - options.paddingRight : 0;
+        const currentHeight = boundsData.bounds ? boundsData.bounds?.height - options.paddingTop - options.paddingBottom : 0;
+
+        const maxWidth =
+            options.paddingFactor *
+            (options.resizeContainer
+                ? Math.max(fixedSize.width - options.paddingLeft - options.paddingRight, childrenSize.width)
+                : Math.max(0, fixedSize.width - options.paddingLeft - options.paddingRight));
+        const maxHeight =
+            options.paddingFactor *
+            (options.resizeContainer
+                ? Math.max(fixedSize.height - options.paddingTop - options.paddingBottom, childrenSize.height)
+                : Math.max(0, fixedSize.height - options.paddingTop - options.paddingBottom));
+
+        const width = Math.max(currentWidth, maxWidth);
+        const height = Math.max(currentHeight, maxHeight);
+
+        // Remaining size that can be grabbed by children with the hGrab option
+        const grabWidth = width - childrenSize.width;
+        // Number of children that request hGrab
+        // FIXME: This approach works fine when only 1 child uses HGrab, but may cause rounding issues
+        // when the grabHeight can't be equally shared by all children.
+        const grabbingChildren = container.children
+            .map(child => this.getChildLayoutOptions(child, options))
+            .filter(opt => opt.hGrab).length;
+
+        if (width > 0 && height > 0) {
+            const offset = this.layoutChildren(container, layouter, options, width, height, grabWidth, grabbingChildren);
+            boundsData.bounds = this.getFinalContainerBounds(container, offset, options, childrenSize.width, childrenSize.height);
+            boundsData.boundsChanged = true;
+        }
+    }
+
+    protected override getChildrenSize(
+        container: SParentElement & LayoutContainer,
+        containerOptions: HBoxLayoutOptionsExt,
+        layouter: StatefulLayouter
+    ): Dimension {
+        let maxWidth = 0;
+        let maxHeight = -1;
+        let isFirst = true;
+        container.children.forEach(child => {
+            if (isLayoutableChild(child)) {
+                const bounds = layouter.getBoundsData(child).bounds;
+                if (bounds !== undefined && Dimension.isValid(bounds)) {
+                    maxWidth += bounds.width;
+                    if (isFirst) {
+                        isFirst = false;
+                    } else {
+                        maxWidth += containerOptions.hGap;
+                    }
+                    maxHeight = Math.max(maxHeight, bounds.height);
+                }
+            }
+        });
+        const result = {
+            width: maxWidth,
+            height: maxHeight
+        };
+        return result;
+    }
+
+    protected override layoutChildren(
+        container: SParentElement & LayoutContainer,
+        layouter: StatefulLayouter,
+        containerOptions: HBoxLayoutOptionsExt,
+        maxWidth: number,
+        maxHeight: number,
+        grabWidth?: number,
+        grabbingChildren?: number
+    ): Point {
+        let currentOffset: Point = {
+            x: containerOptions.paddingLeft + 0.5 * (maxWidth - maxWidth / containerOptions.paddingFactor),
+            y: containerOptions.paddingTop + 0.5 * (maxHeight - maxHeight / containerOptions.paddingFactor)
+        };
+
+        container.children.forEach(child => {
+            if (isLayoutableChild(child)) {
+                const boundsData = layouter.getBoundsData(child);
+                const bounds = boundsData.bounds;
+                const childOptions = this.getChildLayoutOptions(child, containerOptions);
+                if (bounds !== undefined && Dimension.isValid(bounds)) {
+                    currentOffset = this.layoutChild(
+                        child,
+                        boundsData,
+                        bounds,
+                        childOptions,
+                        containerOptions,
+                        currentOffset,
+                        maxWidth,
+                        maxHeight,
+                        grabWidth,
+                        grabbingChildren
+                    );
+                }
+            }
+        });
+        return currentOffset;
+    }
+
+    protected override layoutChild(
+        child: SChildElement,
+        boundsData: BoundsData,
+        bounds: Bounds,
+        childOptions: HBoxLayoutOptionsExt,
+        containerOptions: HBoxLayoutOptionsExt,
+        currentOffset: Point,
+        maxWidth: number,
+        maxHeight: number,
+        grabWidth?: number,
+        grabbingChildren?: number
+    ): Point {
+        const vAlign = childOptions.vGrab ? 'top' : childOptions.vAlign;
+        const dy = this.getDy(vAlign, bounds, maxHeight);
+        let offset = super.layoutChild(child, boundsData, bounds, childOptions, containerOptions, currentOffset, maxWidth, maxHeight);
+        boundsData.bounds = {
+            ...boundsData.bounds!,
+            x: currentOffset.x,
+            y: currentOffset.y + dy
+        };
+        if (childOptions.vGrab) {
+            boundsData.bounds = {
+                x: boundsData.bounds!.x,
+                y: boundsData.bounds!.y,
+                width: boundsData.bounds!.width,
+                height: maxHeight
+            };
+            boundsData.boundsChanged = true;
+        }
+        if (childOptions.hGrab && grabWidth && grabbingChildren) {
+            const width = boundsData.bounds!.width + grabWidth / grabbingChildren;
+            boundsData.bounds = {
+                x: boundsData.bounds!.x,
+                y: boundsData.bounds!.y,
+                width: width,
+                height: boundsData.bounds!.height
+            };
+            boundsData.boundsChanged = true;
+            offset = { x: currentOffset.x + width, y: currentOffset.y };
+        }
+        return offset;
+    }
+
+    protected override getFixedContainerBounds(
+        container: SModelElement,
+        layoutOptions: HBoxLayoutOptionsExt,
+        layouter: StatefulLayouter
+    ): Bounds {
+        const currentContainer = container;
+        // eslint-disable-next-line no-constant-condition
+        if (isBoundsAware(currentContainer)) {
+            const bounds = currentContainer.bounds;
+            const elementOptions = this.getElementLayoutOptions(currentContainer);
+            const width = elementOptions?.prefWidth ?? 0;
+            const height = elementOptions?.prefHeight ?? 0;
+            return { ...bounds, width, height };
+        }
+        return Bounds.EMPTY;
+    }
+
+    protected override getChildLayoutOptions(child: SChildElement, containerOptions: HBoxLayoutOptionsExt): HBoxLayoutOptionsExt {
+        return super.getChildLayoutOptions(child, this.filterContainerOptions(containerOptions)) as HBoxLayoutOptionsExt;
+    }
+
+    protected override getLayoutOptions(element: SModelElement): HBoxLayoutOptionsExt {
+        return super.getLayoutOptions(element) as HBoxLayoutOptionsExt;
+    }
+
+    protected getElementLayoutOptions(element: SModelElement): HBoxLayoutOptionsExt | undefined {
+        return (element as any).layoutOptions;
+    }
+
+    protected override getFinalContainerBounds(
+        container: SParentElement & LayoutContainer,
+        lastOffset: Point,
+        options: HBoxLayoutOptionsExt,
+        maxWidth: number,
+        maxHeight: number
+    ): Bounds {
+        const elementOptions = this.getElementLayoutOptions(container);
+        const width = elementOptions?.prefWidth ?? options.minWidth;
+        const height = elementOptions?.prefHeight ?? options.minHeight;
+
+        const result = {
+            x: container.bounds.x,
+            y: container.bounds.y,
+            width: Math.max(width, maxWidth + options.paddingLeft + options.paddingRight),
+            height: Math.max(height, maxHeight + options.paddingTop + options.paddingBottom)
+        };
+
+        return result;
+    }
+
+    protected override getDefaultLayoutOptions(): HBoxLayoutOptionsExt {
+        return {
+            resizeContainer: true,
+            paddingTop: 5,
+            paddingBottom: 5,
+            paddingLeft: 5,
+            paddingRight: 5,
+            paddingFactor: 1,
+            hGap: 1,
+            vAlign: 'center',
+            minWidth: 0,
+            minHeight: 0,
+            hGrab: false,
+            vGrab: false,
+            // eslint-disable-next-line no-null/no-null
+            prefHeight: null,
+            // eslint-disable-next-line no-null/no-null
+            prefWidth: null
+        };
+    }
+
+    protected filterContainerOptions(containerOptions: HBoxLayoutOptionsExt): HBoxLayoutOptionsExt {
+        // Reset object-specific layout options to default before merging,
+        // to make sure they won't be inherited (grab, prefSize)
+        // eslint-disable-next-line no-null/no-null
+        const localOptions = { vGrab: false, hGrab: false, prefHeight: null, prefWidth: null };
+        return { ...containerOptions, ...localOptions };
+    }
+}