@eclipse-glsp/client 1.1.0-next.c40feb3.207 → 1.1.0-next.c5afbfa.273

package/src/features/select/selection-service.ts

@@ -1,235 +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, distinctAdd, pluck, remove, SelectAction, SelectAllAction } from '@eclipse-glsp/protocol';
-import { inject, injectable, multiInject, optional } from 'inversify';
-import {
-    Command,
-    CommandExecutionContext,
-    ILogger,
-    isSelectable,
-    SChildElement,
-    Selectable,
-    SelectAllCommand as SprottySelectAllCommand,
-    SelectCommand as SprottySelectCommand,
-    SModelElement,
-    SModelRoot
-} from 'sprotty';
-import { SModelRootListener } from '../../base/model/update-model-command';
-import { TYPES } from '../../base/types';
-import { getElements, getMatchingElements } from '../../utils/smodel-util';
-import { IFeedbackActionDispatcher } from '../tool-feedback/feedback-action-dispatcher';
-import { SelectFeedbackAction } from './select-feedback-action';
-
-export interface SelectionListener {
-    selectionChanged(root: Readonly<SModelRoot>, selectedElements: string[]): void;
-}
-
-@injectable()
-export class SelectionService implements SModelRootListener {
-    private root: Readonly<SModelRoot>;
-    private selectedElementIDs: Set<string> = new Set();
-
-    @inject(TYPES.IFeedbackActionDispatcher) protected feedbackDispatcher: IFeedbackActionDispatcher;
-    @inject(TYPES.ILogger) protected logger: ILogger;
-
-    constructor(@multiInject(TYPES.SelectionListener) @optional() protected selectionListeners: SelectionListener[] = []) {}
-
-    register(selectionListener: SelectionListener): void {
-        distinctAdd(this.selectionListeners, selectionListener);
-    }
-
-    deregister(selectionListener: SelectionListener): void {
-        remove(this.selectionListeners, selectionListener);
-    }
-
-    modelRootChanged(root: Readonly<SModelRoot>): void {
-        this.updateSelection(root, [], []);
-    }
-
-    updateSelection(root: Readonly<SModelRoot>, select: string[], deselect: string[]): void {
-        if (root === undefined && select.length === 0 && deselect.length === 0) {
-            return;
-        }
-        const prevRoot = this.root;
-        const prevSelectedElementIDs = new Set(this.selectedElementIDs);
-
-        // update root
-        this.root = root;
-
-        // update selected element IDs and collect deselected elements
-        // - select all elements that are not deselected at the same time (no-op)
-        // - deselect all elements that are not selected at the same time (no-op) but was selected
-        const toSelect = [...select].filter(selectId => deselect.indexOf(selectId) === -1);
-        const toDeselect = [...deselect].filter(deselectId => select.indexOf(deselectId) === -1 && this.selectedElementIDs.has(deselectId));
-        for (const id of toDeselect) {
-            this.selectedElementIDs.delete(id);
-        }
-        for (const id of toSelect) {
-            this.selectedElementIDs.add(id);
-        }
-
-        const deselectedElementIDs = new Set(toDeselect);
-        // see if selected elements still exist in the updated root
-        for (const id of this.selectedElementIDs) {
-            const element = root.index.getById(id);
-            if (element === undefined) {
-                this.selectedElementIDs.delete(id);
-                if (prevRoot !== undefined && prevRoot.index.getById(id)) {
-                    deselectedElementIDs.add(id);
-                }
-            }
-        }
-
-        // only send out changes if there actually are changes, i.e., the root or the selected elements changed
-        const selectionChanged =
-            prevSelectedElementIDs.size !== this.selectedElementIDs.size ||
-            ![...prevSelectedElementIDs].every(value => this.selectedElementIDs.has(value));
-        if (selectionChanged) {
-            // aggregate to feedback action handling all elements as only the last feedback is restored
-            this.dispatchFeedback([
-                SelectFeedbackAction.create({
-                    selectedElementsIDs: [...this.selectedElementIDs],
-                    deselectedElementsIDs: [...deselectedElementIDs]
-                })
-            ]);
-        }
-
-        const rootChanged = prevRoot !== root;
-        if (rootChanged || selectionChanged) {
-            // notify listeners after the feedback action
-            this.notifyListeners(this.root, this.selectedElementIDs);
-        }
-    }
-
-    dispatchFeedback(actions: Action[]): void {
-        this.feedbackDispatcher.registerFeedback(this, actions);
-    }
-
-    notifyListeners(root: SModelRoot, selectedElementIDs: Set<string>): void {
-        this.selectionListeners.forEach(listener => listener.selectionChanged(root, Array.from(selectedElementIDs)));
-    }
-
-    getModelRoot(): Readonly<SModelRoot> {
-        return this.root;
-    }
-
-    getSelectedElements(): Readonly<SModelElement & Selectable>[] {
-        return getElements(this.root.index, Array.from(this.selectedElementIDs), isSelectable);
-    }
-
-    /**
-     * QUERY METHODS
-     */
-
-    getSelectedElementIDs(): string[] {
-        return [...this.selectedElementIDs];
-    }
-
-    hasSelectedElements(): boolean {
-        return this.selectedElementIDs.size > 0;
-    }
-
-    isSingleSelection(): boolean {
-        return this.selectedElementIDs.size === 1;
-    }
-
-    isMultiSelection(): boolean {
-        return this.selectedElementIDs.size > 1;
-    }
-}
-
-/**
- * Handles a {@link SelectAction} and propagates the new selection to the {@link SelectionService}.
- * Other tools might be selection-sensitive which means {@link SelectAction}s must be processed as fast as possible.
- * Handling the action with a command ensures that the action is processed before the next render tick.
- */
-@injectable()
-export class SelectCommand extends Command {
-    static readonly KIND = SprottySelectCommand.KIND;
-
-    protected selected: SModelElement[] = [];
-    protected deselected: SModelElement[] = [];
-
-    constructor(
-        @inject(TYPES.Action) public action: SelectAction,
-        @inject(TYPES.SelectionService) public selectionService: SelectionService
-    ) {
-        super();
-    }
-
-    execute(context: CommandExecutionContext): SModelRoot {
-        const model = context.root;
-        const selectionGuard = (element: any): element is SModelElement => element instanceof SChildElement && isSelectable(element);
-        const selectedElements = getElements(model.index, this.action.selectedElementsIDs, selectionGuard);
-        const deselectedElements = getElements(model.index, this.action.deselectedElementsIDs, selectionGuard);
-
-        this.selectionService.updateSelection(model, pluck(selectedElements, 'id'), pluck(deselectedElements, 'id'));
-        return model;
-    }
-
-    // Basically no-op since client-side undo is not supported in GLSP.
-    undo(context: CommandExecutionContext): SModelRoot {
-        return context.root;
-    }
-
-    // Basically no-op since client-side redo is not supported in GLSP.
-    redo(context: CommandExecutionContext): SModelRoot {
-        return context.root;
-    }
-}
-
-/**
- * Handles a {@link SelectAllAction} and propagates the new selection to the {@link SelectionService}.
- * Other tools might be selection-sensitive which means {@link SelectionAllAction}s must be processed as fast as possible.
- * Handling the action with a command ensures that the action is processed before the next render tick.
- */
-@injectable()
-export class SelectAllCommand extends Command {
-    static readonly KIND = SprottySelectAllCommand.KIND;
-    protected previousSelection: Map<string, boolean> = new Map<string, boolean>();
-
-    constructor(
-        @inject(TYPES.Action) public action: SelectAllAction,
-        @inject(TYPES.SelectionService) public selectionService: SelectionService
-    ) {
-        super();
-    }
-
-    execute(context: CommandExecutionContext): SModelRoot {
-        const model = context.root;
-        const selectionGuard = (element: any): element is SModelElement => element instanceof SChildElement && isSelectable(element);
-
-        const selectables = getMatchingElements(model.index, selectionGuard);
-        const selectableIds = pluck(selectables, 'id');
-        if (this.action.select) {
-            this.selectionService.updateSelection(model, selectableIds, []);
-        } else {
-            this.selectionService.updateSelection(model, [], selectableIds);
-        }
-
-        return model;
-    }
-
-    // Basically no-op since client-side undo is not supported in GLSP.
-    undo(context: CommandExecutionContext): SModelRoot {
-        return context.root;
-    }
-
-    // Basically no-op since client-side redo is not supported in GLSP.
-    redo(context: CommandExecutionContext): SModelRoot {
-        return context.root;
-    }
-}

package/src/features/source-model-watcher/di.config.ts

@@ -1,25 +0,0 @@
-/********************************************************************************
- * Copyright (c) 2020-2021 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 { SourceModelChangedAction } from '@eclipse-glsp/protocol';
-import { ContainerModule } from 'inversify';
-import { configureActionHandler } from 'sprotty';
-import { SourceModelChangedActionHandler } from './source-model-changed-action-handler';
-
-const sourceModelWatcherModule = new ContainerModule((bind, _unbind, isBound) => {
-    configureActionHandler({ bind, isBound }, SourceModelChangedAction.KIND, SourceModelChangedActionHandler);
-});
-
-export default sourceModelWatcherModule;

package/src/features/tool-feedback/change-bounds-tool-feedback.ts

@@ -1,280 +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, hasStringProp, Point } from '@eclipse-glsp/protocol';
-import { inject, injectable } from 'inversify';
-import { VNode } from 'snabbdom';
-import {
-    CommandExecutionContext,
-    CommandReturn,
-    ElementMove,
-    findParentByFeature,
-    isMoveable,
-    isSelectable,
-    isViewport,
-    MouseListener,
-    MoveAction,
-    SChildElement,
-    SModelElement,
-    SModelRoot,
-    TYPES
-} from 'sprotty';
-import { forEachElement } from '../../utils/smodel-util';
-import { addResizeHandles, isResizable, removeResizeHandles, SResizeHandle } from '../change-bounds/model';
-import { createMovementRestrictionFeedback, removeMovementRestrictionFeedback } from '../change-bounds/movement-restrictor';
-import { CursorCSS, cursorFeedbackAction } from '../tool-feedback/css-feedback';
-import { ChangeBoundsTool } from '../tools/change-bounds-tool';
-import { FeedbackCommand } from './model';
-
-export interface ShowChangeBoundsToolResizeFeedbackAction extends Action {
-    kind: typeof ShowChangeBoundsToolResizeFeedbackAction.KIND;
-
-    elementId: string;
-}
-
-export namespace ShowChangeBoundsToolResizeFeedbackAction {
-    export const KIND = 'showChangeBoundsToolResizeFeedback';
-
-    export function is(object: any): object is ShowChangeBoundsToolResizeFeedbackAction {
-        return Action.hasKind(object, KIND) && hasStringProp(object, 'elementId');
-    }
-
-    export function create(elementId: string): ShowChangeBoundsToolResizeFeedbackAction {
-        return {
-            kind: KIND,
-            elementId
-        };
-    }
-}
-
-export interface HideChangeBoundsToolResizeFeedbackAction extends Action {
-    kind: typeof HideChangeBoundsToolResizeFeedbackAction.KIND;
-}
-
-export namespace HideChangeBoundsToolResizeFeedbackAction {
-    export const KIND = 'hideChangeBoundsToolResizeFeedback';
-
-    export function is(object: any): object is HideChangeBoundsToolResizeFeedbackAction {
-        return Action.hasKind(object, KIND);
-    }
-
-    export function create(): HideChangeBoundsToolResizeFeedbackAction {
-        return { kind: KIND };
-    }
-}
-
-@injectable()
-export class ShowChangeBoundsToolResizeFeedbackCommand extends FeedbackCommand {
-    static readonly KIND = ShowChangeBoundsToolResizeFeedbackAction.KIND;
-
-    @inject(TYPES.Action) protected action: ShowChangeBoundsToolResizeFeedbackAction;
-
-    execute(context: CommandExecutionContext): CommandReturn {
-        const index = context.root.index;
-
-        forEachElement(index, isResizable, removeResizeHandles);
-
-        if (this.action.elementId) {
-            const resizeElement = index.getById(this.action.elementId);
-            if (resizeElement && isResizable(resizeElement)) {
-                addResizeHandles(resizeElement);
-            }
-        }
-        return context.root;
-    }
-}
-
-@injectable()
-export class HideChangeBoundsToolResizeFeedbackCommand extends FeedbackCommand {
-    static readonly KIND = HideChangeBoundsToolResizeFeedbackAction.KIND;
-
-    @inject(TYPES.Action) protected action: HideChangeBoundsToolResizeFeedbackAction;
-
-    execute(context: CommandExecutionContext): CommandReturn {
-        const index = context.root.index;
-        forEachElement(index, isResizable, removeResizeHandles);
-        return context.root;
-    }
-}
-
-/**
- * This mouse listener provides visual feedback for moving by sending client-side
- * `MoveAction`s while elements are selected and dragged. This will also update
- * their bounds, which is important, as it is not only required for rendering
- * the visual feedback but also the basis for sending the change to the server
- * (see also `tools/MoveTool`).
- */
-export class FeedbackMoveMouseListener extends MouseListener {
-    protected hasDragged = false;
-    protected startDragPosition: Point | undefined;
-    protected elementId2startPos = new Map<string, Point>();
-
-    constructor(protected tool: ChangeBoundsTool) {
-        super();
-    }
-
-    override mouseDown(target: SModelElement, event: MouseEvent): Action[] {
-        if (event.button === 0 && !(target instanceof SResizeHandle)) {
-            const moveable = findParentByFeature(target, isMoveable);
-            if (moveable !== undefined) {
-                this.startDragPosition = { x: event.pageX, y: event.pageY };
-            } else {
-                this.startDragPosition = undefined;
-            }
-            this.hasDragged = false;
-        }
-        return [];
-    }
-
-    override mouseMove(target: SModelElement, event: MouseEvent): Action[] {
-        const result: Action[] = [];
-        if (event.buttons === 0) {
-            this.mouseUp(target, event);
-        } else if (this.startDragPosition) {
-            if (this.elementId2startPos.size === 0) {
-                this.collectStartPositions(target.root);
-            }
-            this.hasDragged = true;
-            const moveAction = this.getElementMoves(target, event, false);
-            if (moveAction) {
-                result.push(moveAction);
-                result.push(cursorFeedbackAction(CursorCSS.MOVE));
-            }
-        }
-        return result;
-    }
-
-    protected collectStartPositions(root: SModelRoot): void {
-        const selectedElements = root.index.all().filter(element => isSelectable(element) && element.selected);
-        const elementsSet = new Set(selectedElements);
-        selectedElements
-            .filter(element => !this.isChildOfSelected(elementsSet, element))
-            .forEach(element => {
-                if (isMoveable(element)) {
-                    this.elementId2startPos.set(element.id, element.position);
-                }
-            });
-    }
-
-    protected isChildOfSelected(selectedElements: Set<SModelElement>, element: SModelElement): boolean {
-        while (element instanceof SChildElement) {
-            element = element.parent;
-            if (selectedElements.has(element)) {
-                return true;
-            }
-        }
-        return false;
-    }
-
-    protected getElementMoves(target: SModelElement, event: MouseEvent, finished: boolean): MoveAction | undefined {
-        if (!this.startDragPosition) {
-            return undefined;
-        }
-        const elementMoves: ElementMove[] = [];
-        const viewport = findParentByFeature(target, isViewport);
-        const zoom = viewport ? viewport.zoom : 1;
-        const delta = {
-            x: (event.pageX - this.startDragPosition.x) / zoom,
-            y: (event.pageY - this.startDragPosition.y) / zoom
-        };
-        this.elementId2startPos.forEach((startPosition, elementId) => {
-            const element = target.root.index.getById(elementId);
-            if (element) {
-                let toPosition = this.snap(
-                    {
-                        x: startPosition.x + delta.x,
-                        y: startPosition.y + delta.y
-                    },
-                    element,
-                    !event.shiftKey
-                );
-
-                if (isMoveable(element)) {
-                    toPosition = this.validateMove(startPosition, toPosition, element, finished);
-                    elementMoves.push({
-                        elementId: element.id,
-                        fromPosition: {
-                            x: element.position.x,
-                            y: element.position.y
-                        },
-                        toPosition
-                    });
-                }
-            }
-        });
-        if (elementMoves.length > 0) {
-            return MoveAction.create(elementMoves, { animate: false, finished });
-        } else {
-            return undefined;
-        }
-    }
-
-    protected validateMove(startPostion: Point, toPosition: Point, element: SModelElement, isFinished: boolean): Point {
-        let newPosition = toPosition;
-        if (this.tool.movementRestrictor) {
-            const valid = this.tool.movementRestrictor.validate(element, toPosition);
-            let action;
-            if (!valid) {
-                action = createMovementRestrictionFeedback(element, this.tool.movementRestrictor);
-
-                if (isFinished) {
-                    newPosition = startPostion;
-                }
-            } else {
-                action = removeMovementRestrictionFeedback(element, this.tool.movementRestrictor);
-            }
-
-            this.tool.dispatchFeedback([action], this);
-        }
-        return newPosition;
-    }
-
-    protected snap(position: Point, element: SModelElement, isSnap: boolean): Point {
-        if (isSnap && this.tool.snapper) {
-            return this.tool.snapper.snap(position, element);
-        } else {
-            return position;
-        }
-    }
-
-    override mouseEnter(target: SModelElement, event: MouseEvent): Action[] {
-        if (target instanceof SModelRoot && event.buttons === 0 && !this.startDragPosition) {
-            this.mouseUp(target, event);
-        }
-        return [];
-    }
-
-    override mouseUp(target: SModelElement, event: MouseEvent): Action[] {
-        const result: Action[] = [];
-        if (this.startDragPosition) {
-            const moveAction = this.getElementMoves(target, event, true);
-            if (moveAction) {
-                result.push(moveAction);
-            }
-            if (this.tool.movementRestrictor) {
-                this.tool.deregisterFeedback([removeMovementRestrictionFeedback(target, this.tool.movementRestrictor)], this);
-            }
-            result.push(cursorFeedbackAction(CursorCSS.DEFAULT));
-        }
-        this.hasDragged = false;
-        this.startDragPosition = undefined;
-        this.elementId2startPos.clear();
-        return result;
-    }
-
-    override decorate(vnode: VNode, _element: SModelElement): VNode {
-        return vnode;
-    }
-}