@eclipse-glsp/client 1.1.0-next.fdfeeeb.193 → 2.0.0

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

@@ -1,26 +0,0 @@
-/********************************************************************************
- * 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
- * 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 { ContainerModule } from 'inversify';
-import '../../../css/decoration.css';
-import { TYPES } from '../../base/types';
-import { GlspDecorationPlacer } from './decoration-placer';
-
-const glspDecorationModule = new ContainerModule((bind, _unbind, isBound) => {
-    bind(GlspDecorationPlacer).toSelf().inSingletonScope();
-    bind(TYPES.IVNodePostprocessor).toService(GlspDecorationPlacer);
-});
-
-export default glspDecorationModule;

package/src/features/edit-label/di.config.ts

@@ -1,29 +0,0 @@
-/********************************************************************************
- * 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
- * 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 { ContainerModule } from 'inversify';
-import { ApplyLabelEditCommand, configureCommand } from 'sprotty';
-import { TYPES } from '../../base/types';
-import { DirectLabelEditTool } from './edit-label-tool';
-import { BalloonLabelValidationDecorator, ServerEditLabelValidator } from './edit-label-validator';
-
-const glspEditLabelModule = new ContainerModule((bind, _unbind, isBound, _rebind) => {
-    bind(TYPES.IEditLabelValidator).to(ServerEditLabelValidator);
-    bind(TYPES.IEditLabelValidationDecorator).to(BalloonLabelValidationDecorator);
-    bind(TYPES.IDefaultTool).to(DirectLabelEditTool);
-    configureCommand({ bind, isBound }, ApplyLabelEditCommand);
-});
-
-export default glspEditLabelModule;

package/src/features/edit-label/edit-label-tool.ts

@@ -1,50 +0,0 @@
-/********************************************************************************
- * 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
- * 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 { injectable } from 'inversify';
-import { EditLabelKeyListener, EditLabelMouseListener, KeyListener, MouseListener } from 'sprotty';
-import { BaseGLSPTool } from '../tools/base-glsp-tool';
-
-@injectable()
-export class DirectLabelEditTool extends BaseGLSPTool {
-    static readonly ID = 'glsp.direct-label-edit-tool';
-
-    protected editLabelMouseListener: MouseListener;
-    protected editLabelKeyListener: KeyListener;
-
-    get id(): string {
-        return DirectLabelEditTool.ID;
-    }
-
-    protected createEditLabelMouseListener(): MouseListener {
-        return new EditLabelMouseListener();
-    }
-
-    protected createEditLabelKeyListener(): KeyListener {
-        return new EditLabelKeyListener();
-    }
-
-    enable(): void {
-        this.editLabelKeyListener = this.createEditLabelKeyListener();
-        this.editLabelMouseListener = this.createEditLabelMouseListener();
-        this.mouseTool.register(this.editLabelMouseListener);
-        this.keyTool.register(this.editLabelKeyListener);
-    }
-
-    disable(): void {
-        this.keyTool.deregister(this.editLabelKeyListener);
-        this.mouseTool.deregister(this.editLabelMouseListener);
-    }
-}

package/src/features/edit-label/edit-label-validator.ts

@@ -1,99 +0,0 @@
-/********************************************************************************
- * 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
- * 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 { Action, RequestEditValidationAction, SetEditValidationResultAction, ValidationStatus } from '@eclipse-glsp/protocol';
-import { inject, injectable } from 'inversify';
-import {
-    EditableLabel,
-    EditLabelValidationResult,
-    IEditLabelValidationDecorator,
-    IEditLabelValidator,
-    Severity,
-    SModelElement,
-    TYPES
-} from 'sprotty';
-import { GLSPActionDispatcher } from '../../base/action-dispatcher';
-
-export namespace LabelEditValidation {
-    export const CONTEXT_ID = 'label-edit';
-
-    export function toEditLabelValidationResult(status: ValidationStatus): EditLabelValidationResult {
-        const message = status.message;
-        let severity = 'ok' as Severity;
-        if (ValidationStatus.isError(status)) {
-            severity = 'error' as Severity;
-        } else if (ValidationStatus.isWarning(status)) {
-            severity = 'warning' as Severity;
-        }
-        return { message, severity };
-    }
-
-    export function createValidationRequestAction(value: string, labelId: string): RequestEditValidationAction {
-        return RequestEditValidationAction.create({ contextId: CONTEXT_ID, modelElementId: labelId, text: value });
-    }
-}
-
-@injectable()
-export class ServerEditLabelValidator implements IEditLabelValidator {
-    @inject(TYPES.IActionDispatcher) protected actionDispatcher: GLSPActionDispatcher;
-
-    validate(value: string, label: EditableLabel & SModelElement): Promise<EditLabelValidationResult> {
-        const action = LabelEditValidation.createValidationRequestAction(value, label.id);
-        return this.actionDispatcher.requestUntil(action).then(response => this.getValidationResultFromResponse(response));
-    }
-
-    getValidationResultFromResponse(action: Action): EditLabelValidationResult {
-        if (SetEditValidationResultAction.is(action)) {
-            return LabelEditValidation.toEditLabelValidationResult(action.status);
-        }
-        return { severity: 'ok' as Severity };
-    }
-}
-
-@injectable()
-export class BalloonLabelValidationDecorator implements IEditLabelValidationDecorator {
-    decorate(input: HTMLInputElement, result: EditLabelValidationResult): void {
-        const containerElement = input.parentElement;
-        if (!containerElement) {
-            return;
-        }
-        if (result.message) {
-            containerElement.setAttribute('data-balloon', result.message);
-            containerElement.setAttribute('data-balloon-pos', 'up-left');
-            containerElement.setAttribute('data-balloon-visible', 'true');
-        }
-        switch (result.severity) {
-            case 'ok':
-                containerElement.classList.add('validation-ok');
-                break;
-            case 'warning':
-                containerElement.classList.add('validation-warning');
-                break;
-            case 'error':
-                containerElement.classList.add('validation-error');
-                break;
-        }
-    }
-
-    dispose(input: HTMLInputElement): void {
-        const containerElement = input.parentElement;
-        if (containerElement) {
-            containerElement.removeAttribute('data-balloon');
-            containerElement.removeAttribute('data-balloon-pos');
-            containerElement.removeAttribute('data-balloon-visible');
-            containerElement.classList.remove('validation-ok', 'validation-warning', 'validation-error');
-        }
-    }
-}

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

@@ -1,29 +0,0 @@
-/********************************************************************************
- * 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
- * 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 { SetTypeHintsAction } from '@eclipse-glsp/protocol';
-import { ContainerModule } from 'inversify';
-import { configureActionHandler, configureCommand } from 'sprotty';
-import { TYPES } from '../../base/types';
-import { ApplyTypeHintsCommand, TypeHintProvider } from './type-hints';
-
-const modelHintsModule = new ContainerModule((bind, _unbind, isBound) => {
-    bind(TypeHintProvider).toSelf().inSingletonScope();
-    bind(TYPES.ITypeHintProvider).toService(TypeHintProvider);
-    configureActionHandler({ bind, isBound }, SetTypeHintsAction.KIND, TypeHintProvider);
-    configureCommand({ bind, isBound }, ApplyTypeHintsCommand);
-});
-
-export default modelHintsModule;

package/src/features/hints/type-hints.ts

@@ -1,205 +0,0 @@
-/********************************************************************************
- * 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
- * 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 { Action, EdgeTypeHint, SetTypeHintsAction, ShapeTypeHint, TypeHint } from '@eclipse-glsp/protocol';
-import { inject, injectable } from 'inversify';
-import {
-    CommandExecutionContext,
-    CommandReturn,
-    Connectable,
-    connectableFeature,
-    deletableFeature,
-    editFeature,
-    FeatureSet,
-    IActionHandler,
-    ICommand,
-    moveFeature,
-    SEdge,
-    SModelElement,
-    SModelRoot,
-    SShapeElement
-} from 'sprotty';
-import { TYPES } from '../../base/types';
-import { getElementTypeId, hasCompatibleType } from '../../utils/smodel-util';
-import { resizeFeature } from '../change-bounds/model';
-import { reconnectFeature } from '../reconnect/model';
-import { IFeedbackActionDispatcher } from '../tool-feedback/feedback-action-dispatcher';
-import { FeedbackCommand } from '../tool-feedback/model';
-import { Containable, containerFeature, reparentFeature } from './model';
-
-/**
- * Is dispatched by the {@link TypeHintProvider} to apply the type hints received from the server
- * onto the graphical model. The action is dispatched as persistent feedback to ensure the applied type hints
- * don't get lost after a server-side model update.
- */
-export interface ApplyTypeHintsAction extends Action {
-    kind: typeof ApplyTypeHintsAction.KIND;
-}
-
-export namespace ApplyTypeHintsAction {
-    export const KIND = 'applyTypeHints';
-
-    export function is(object: any): object is ApplyTypeHintsAction {
-        return Action.hasKind(object, KIND);
-    }
-
-    export function create(): ApplyTypeHintsAction {
-        return { kind: KIND };
-    }
-}
-
-@injectable()
-export class ApplyTypeHintsCommand extends FeedbackCommand {
-    public static KIND = ApplyTypeHintsAction.KIND;
-    public override readonly priority = 10;
-
-    @inject(TYPES.ITypeHintProvider) protected typeHintProvider: ITypeHintProvider;
-
-    constructor(@inject(TYPES.Action) protected action: Action) {
-        super();
-    }
-
-    execute(context: CommandExecutionContext): CommandReturn {
-        context.root.index.all().forEach(element => {
-            if (element instanceof SShapeElement || element instanceof SModelRoot) {
-                this.applyShapeTypeHint(element);
-            } else if (element instanceof SEdge) {
-                return this.applyEdgeTypeHint(element);
-            }
-        });
-        return context.root;
-    }
-
-    protected applyEdgeTypeHint(element: SModelElement): void {
-        const hint = this.typeHintProvider.getEdgeTypeHint(element);
-        if (hint && isModifiableFeatureSet(element.features)) {
-            addOrRemove(element.features, deletableFeature, hint.deletable);
-            addOrRemove(element.features, editFeature, hint.routable);
-            addOrRemove(element.features, reconnectFeature, hint.repositionable);
-        }
-    }
-
-    protected applyShapeTypeHint(element: SModelElement): void {
-        const hint = this.typeHintProvider.getShapeTypeHint(element);
-        if (hint && isModifiableFeatureSet(element.features)) {
-            addOrRemove(element.features, deletableFeature, hint.deletable);
-            addOrRemove(element.features, moveFeature, hint.repositionable);
-            addOrRemove(element.features, resizeFeature, hint.resizable);
-            addOrRemove(element.features, reparentFeature, hint.reparentable);
-
-            addOrRemove(element.features, containerFeature, true);
-            const containable = createContainable(hint);
-            Object.assign(element, containable);
-
-            addOrRemove(element.features, connectableFeature, true);
-            const validSourceEdges = this.typeHintProvider.getValidEdgeElementTypes(element, 'source');
-            const validTargetEdges = this.typeHintProvider.getValidEdgeElementTypes(element, 'target');
-            const connectable = createConnectable(validSourceEdges, validTargetEdges);
-            Object.assign(element, connectable);
-        }
-    }
-}
-
-function createConnectable(validSourceEdges: string[], validTargetEdges: string[]): Connectable {
-    return {
-        canConnect: (routable, role) =>
-            role === 'source' ? validSourceEdges.includes(routable.type) : validTargetEdges.includes(routable.type)
-    };
-}
-
-function createContainable(hint: ShapeTypeHint): Containable {
-    return {
-        isContainableElement: element =>
-            hint.containableElementTypeIds ? hint.containableElementTypeIds.includes(getElementTypeId(element)) : false
-    };
-}
-
-function addOrRemove(features: Set<symbol>, feature: symbol, add: boolean): void {
-    if (add && !features.has(feature)) {
-        features.add(feature);
-    } else if (!add && features.has(feature)) {
-        features.delete(feature);
-    }
-}
-
-function isModifiableFeatureSet(featureSet?: FeatureSet): featureSet is FeatureSet & Set<symbol> {
-    return featureSet !== undefined && featureSet instanceof Set;
-}
-
-export interface ITypeHintProvider {
-    getShapeTypeHint(input: SModelElement | SModelElement | string): ShapeTypeHint | undefined;
-    getEdgeTypeHint(input: SModelElement | SModelElement | string): EdgeTypeHint | undefined;
-    getValidEdgeElementTypes(input: SModelElement | SModelElement | string, role: 'source' | 'target'): string[];
-}
-
-@injectable()
-export class TypeHintProvider implements IActionHandler, ITypeHintProvider {
-    @inject(TYPES.IFeedbackActionDispatcher)
-    protected feedbackActionDispatcher: IFeedbackActionDispatcher;
-
-    protected shapeHints: Map<string, ShapeTypeHint> = new Map();
-    protected edgeHints: Map<string, EdgeTypeHint> = new Map();
-
-    handle(action: Action): ICommand | Action | void {
-        if (SetTypeHintsAction.is(action)) {
-            action.shapeHints.forEach(hint => this.shapeHints.set(hint.elementTypeId, hint));
-            action.edgeHints.forEach(hint => this.edgeHints.set(hint.elementTypeId, hint));
-            this.feedbackActionDispatcher.registerFeedback(this, [ApplyTypeHintsAction.create()]);
-        }
-    }
-
-    getValidEdgeElementTypes(input: SModelElement | SModelElement | string, role: 'source' | 'target'): string[] {
-        const elementTypeId = getElementTypeId(input);
-        if (role === 'source') {
-            return Array.from(
-                Array.from(this.edgeHints.values())
-                    .filter(hint =>
-                        hint.sourceElementTypeIds.some(sourceElementTypeId => hasCompatibleType(elementTypeId, sourceElementTypeId))
-                    )
-                    .map(hint => hint.elementTypeId)
-            );
-        } else {
-            return Array.from(
-                Array.from(this.edgeHints.values())
-                    .filter(hint =>
-                        hint.targetElementTypeIds.some(targetElementTypeId => hasCompatibleType(elementTypeId, targetElementTypeId))
-                    )
-                    .map(hint => hint.elementTypeId)
-            );
-        }
-    }
-
-    getShapeTypeHint(input: SModelElement | SModelElement | string): ShapeTypeHint | undefined {
-        return getTypeHint(input, this.shapeHints);
-    }
-
-    getEdgeTypeHint(input: SModelElement | SModelElement | string): EdgeTypeHint | undefined {
-        return getTypeHint(input, this.edgeHints);
-    }
-}
-
-function getTypeHint<T extends TypeHint>(input: SModelElement | SModelElement | string, hints: Map<string, T>): T | undefined {
-    const type = getElementTypeId(input);
-    let hint = hints.get(type);
-    // Check subtypes
-    if (hint === undefined) {
-        const subtypes = type.split(':');
-        while (hint === undefined && subtypes.length > 0) {
-            subtypes.pop();
-            hint = hints.get(subtypes.join(':'));
-        }
-    }
-    return hint;
-}

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

@@ -1,66 +0,0 @@
-/********************************************************************************
- * 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
- * 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 { ContainerModule } from 'inversify';
-import {
-    CenterCommand,
-    ClosePopupActionHandler,
-    configureActionHandler,
-    configureCommand,
-    EnableDefaultToolsAction,
-    EnableToolsAction,
-    FitToScreenCommand,
-    HoverFeedbackCommand,
-    HoverKeyListener,
-    HoverState,
-    MoveCommand,
-    PopupHoverMouseListener,
-    SetPopupModelCommand,
-    SetViewportCommand,
-    TYPES
-} from 'sprotty';
-import { PopupPositionUpdater } from 'sprotty/lib/features/hover/popup-position-updater';
-import { FocusStateChangedAction } from '../../base/actions/focus-change-action';
-import { GlspHoverMouseListener } from './hover';
-
-const glspHoverModule = new ContainerModule((bind, _unbind, isBound) => {
-    bind(TYPES.PopupVNodePostprocessor).to(PopupPositionUpdater).inSingletonScope();
-    bind(GlspHoverMouseListener).toSelf().inSingletonScope();
-    bind(TYPES.MouseListener).toService(GlspHoverMouseListener);
-    bind(TYPES.PopupMouseListener).to(PopupHoverMouseListener);
-    bind(TYPES.KeyListener).to(HoverKeyListener);
-    bind<HoverState>(TYPES.HoverState).toConstantValue({
-        mouseOverTimer: undefined,
-        mouseOutTimer: undefined,
-        popupOpen: false,
-        previousPopupElement: undefined
-    });
-    bind(ClosePopupActionHandler).toSelf().inSingletonScope();
-
-    const context = { bind, isBound };
-    configureCommand(context, HoverFeedbackCommand);
-    configureCommand(context, SetPopupModelCommand);
-    configureActionHandler(context, SetPopupModelCommand.KIND, ClosePopupActionHandler);
-    configureActionHandler(context, FitToScreenCommand.KIND, ClosePopupActionHandler);
-    configureActionHandler(context, CenterCommand.KIND, ClosePopupActionHandler);
-    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/layout/di.config.ts

@@ -1,40 +0,0 @@
-/********************************************************************************
- * 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
- * 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 { ContainerModule } from 'inversify';
-import { configureActionHandler, configureLayout, HBoxLayouter, TYPES, VBoxLayouter } from 'sprotty';
-import { FreeFormLayouter } from './freeform-layout';
-import { HBoxLayouterExt } from './hbox-layout';
-import {
-    AlignElementsAction,
-    AlignElementsActionHandler,
-    ResizeElementsAction,
-    ResizeElementsActionHandler
-} from './layout-elements-action';
-import { LayouterExt } from './layouter';
-import { VBoxLayouterExt } from './vbox-layout';
-
-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 layoutModule;

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

@@ -1,124 +0,0 @@
-/********************************************************************************
- * 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, LayoutContainer, SChildElement, SParentElement, StatefulLayouter } from 'sprotty';
-import { AbstractLayout } from 'sprotty/lib/features/bounds/abstract-layout';
-import { AbstractLayoutOptions } from 'sprotty/lib/features/bounds/layout-options';
-
-/**
- * Layouts children of a container with explit X/Y positions
- */
-@injectable()
-export class FreeFormLayouter extends AbstractLayout<AbstractLayoutOptions> {
-    static KIND = 'freeform';
-
-    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);
-
-        // The real size of the compartment will be determined by the parent node layout;
-        // we only need to compute the bounds required to layout the children.
-
-        const maxWidth = childrenSize.width > 0 ? childrenSize.width + options.paddingLeft + options.paddingRight : 0;
-        const maxHeight = childrenSize.height > 0 ? childrenSize.height + options.paddingTop + options.paddingBottom : 0;
-        if (maxWidth > 0 && maxHeight > 0) {
-            const offset = this.layoutChildren(container, layouter, options, maxWidth, maxHeight);
-            boundsData.bounds = this.getFinalContainerBounds(container, offset, options, maxWidth, maxHeight);
-            boundsData.boundsChanged = true;
-        } else {
-            boundsData.bounds = { x: boundsData.bounds!.x, y: boundsData.bounds!.y, width: 0, height: 0 };
-            boundsData.boundsChanged = true;
-        }
-    }
-
-    protected getChildrenSize(
-        container: SParentElement & LayoutContainer,
-        containerOptions: AbstractLayoutOptions,
-        layouter: StatefulLayouter
-    ): Dimension {
-        let maxX = 0;
-        let maxY = 0;
-        container.children.forEach(child => {
-            const bounds = layouter.getBoundsData(child).bounds;
-            if (bounds !== undefined && Dimension.isValid(bounds)) {
-                const childMaxX = bounds.x + bounds.width;
-                const childMaxY = bounds.y + bounds.height;
-                maxX = Math.max(maxX, childMaxX);
-                maxY = Math.max(maxY, childMaxY);
-            }
-        });
-        return {
-            width: maxX,
-            height: maxY
-        };
-    }
-
-    protected layoutChild(
-        child: SChildElement,
-        boundsData: BoundsData,
-        bounds: Bounds,
-        childOptions: AbstractLayoutOptions,
-        containerOptions: AbstractLayoutOptions,
-        currentOffset: Point,
-        maxWidth: number,
-        maxHeight: number
-    ): Point {
-        boundsData.bounds = {
-            x: (child as any).bounds.x,
-            y: (child as any).bounds.y,
-            width: bounds.width,
-            height: bounds.height
-        };
-        boundsData.boundsChanged = true;
-        return currentOffset;
-    }
-
-    protected override getFinalContainerBounds(
-        container: SParentElement & LayoutContainer,
-        lastOffset: Point,
-        options: AbstractLayoutOptions,
-        maxWidth: number,
-        maxHeight: number
-    ): Bounds {
-        const result = {
-            x: container.bounds.x,
-            y: container.bounds.y,
-            width: Math.max(options.minWidth, maxWidth + options.paddingLeft + options.paddingRight),
-            height: Math.max(options.minHeight, maxHeight + options.paddingTop + options.paddingBottom)
-        };
-
-        return result;
-    }
-
-    protected getDefaultLayoutOptions(): AbstractLayoutOptions {
-        return {
-            resizeContainer: true,
-            paddingTop: 0,
-            paddingBottom: 0,
-            paddingLeft: 0,
-            paddingRight: 0,
-            paddingFactor: 1,
-            minWidth: 0,
-            minHeight: 0
-        };
-    }
-
-    protected spread(a: AbstractLayoutOptions, b: AbstractLayoutOptions): AbstractLayoutOptions {
-        return { ...a, ...b };
-    }
-}