@eclipse-glsp/client 2.1.0-next.304 → 2.1.0-next.306

package/src/features/helper-lines/helper-line-manager-default.ts

@@ -19,8 +19,8 @@ import {
     GModelElement,
     GModelRoot,
     IActionHandler,
-    ISnapper,
     MoveAction,
+    Point,
     SetBoundsAction,
     TYPES
 } from '@eclipse-glsp/sprotty';
@@ -28,33 +28,81 @@ import { inject, injectable, optional, postConstruct } from 'inversify';
 import { IFeedbackActionDispatcher } from '../../base/feedback/feedback-action-dispatcher';
 import { ISelectionListener, SelectionService } from '../../base/selection-service';
 import { SetBoundsFeedbackAction } from '../bounds/set-bounds-feedback-command';
-import { GridSnapper } from '../change-bounds/snap';
 import { MoveFinishedEventAction, MoveInitializedEventAction } from '../tools/change-bounds/change-bounds-tool-feedback';
-import { DrawHelperLinesFeedbackAction, RemoveHelperLinesFeedbackAction, ViewportLineType } from './helper-line-feedback';
+import {
+    AlignmentElementFilter,
+    DEFAULT_ALIGNABLE_ELEMENT_FILTER,
+    DEFAULT_DEBUG,
+    DEFAULT_ELEMENT_LINES,
+    DEFAULT_EPSILON,
+    DEFAULT_VIEWPORT_LINES,
+    DrawHelperLinesFeedbackAction,
+    RemoveHelperLinesFeedbackAction,
+    ViewportLineType
+} from './helper-line-feedback';
 import { IHelperLineManager } from './helper-line-manager';
 import { Direction, HelperLineType } from './model';
 
+export interface IHelperLineOptions {
+    /**
+     * A list of helper line types that should be rendered when elements are aligned.
+     * Defaults to all possible alignments.
+     */
+    elementLines?: HelperLineType[];
+    /**
+     * A list of helper line types that should be rendered when an element is aligned with the viewport.
+     * Defaults to middle and center alignment.
+     */
+    viewportLines?: ViewportLineType[];
+    /**
+     * The minimum difference between two coordinates
+     * Defaults to 1.
+     */
+    alignmentEpsilon?: number;
+    /**
+     * A filter that is applied to determine on which elements the alignment calculation is performed.
+     * By default all top-level bounds-aware, non-routable elements that are visible on the canvas are considered.
+     */
+    alignmentElementFilter?: AlignmentElementFilter;
+    /**
+     * The minimum move delta that is necessary for an element to break through a helper line.
+     * Defaults to { x: 1, y: 1 } whereas the x represents the horizontal distance and y represents the vertical distance.
+     */
+    minimumMoveDelta?: Point;
+
+    /**
+     * Produces debug output.
+     * Defaults to false.
+     */
+    debug?: boolean;
+}
+
+export const DEFAULT_MOVE_DELTA = { x: 1, y: 1 };
+
+export const DEFAULT_HELPER_LINE_OPTIONS: Required<IHelperLineOptions> = {
+    elementLines: DEFAULT_ELEMENT_LINES,
+    viewportLines: DEFAULT_VIEWPORT_LINES,
+    alignmentEpsilon: DEFAULT_EPSILON,
+    alignmentElementFilter: DEFAULT_ALIGNABLE_ELEMENT_FILTER,
+    minimumMoveDelta: DEFAULT_MOVE_DELTA,
+    debug: DEFAULT_DEBUG
+};
+
 @injectable()
 export class HelperLineManager implements IActionHandler, ISelectionListener, IHelperLineManager {
     @inject(TYPES.IFeedbackActionDispatcher) protected feedbackDispatcher: IFeedbackActionDispatcher;
     @inject(SelectionService) protected selectionService: SelectionService;
-    @optional() @inject(TYPES.ISnapper) protected snapper?: ISnapper;
+    @optional() @inject(TYPES.IHelperLineOptions) protected userOptions?: IHelperLineOptions;
 
-    protected snapSize = { x: 20, y: 20 };
+    protected options: Required<IHelperLineOptions>;
     protected feedback: DisposableCollection = new DisposableCollection();
 
-    protected elementLines?: HelperLineType[];
-    protected viewportLines?: ViewportLineType[];
-    protected alignmentEpsilon?: number;
-
     @postConstruct()
     protected init(): void {
+        this.options = { ...DEFAULT_HELPER_LINE_OPTIONS, ...this.userOptions };
         this.selectionService.onSelectionChanged(change =>
             this.selectionChanged(change.root, change.selectedElements, change.deselectedElements)
         );
-        if (this.snapper instanceof GridSnapper) {
-            this.snapSize = { x: this.snapper.grid.x * 2, y: this.snapper.grid.y * 2 };
-        }
     }
 
     handle(action: Action): void {
@@ -90,12 +138,7 @@ export class HelperLineManager implements IActionHandler, ISelectionListener, IH
     }
 
     protected createHelperLineFeedback(elementIds: string[]): DrawHelperLinesFeedbackAction {
-        return DrawHelperLinesFeedbackAction.create({
-            elementIds,
-            elementLines: this.elementLines,
-            viewportLines: this.viewportLines,
-            alignmentEpsilon: this.alignmentEpsilon
-        });
+        return DrawHelperLinesFeedbackAction.create({ elementIds, ...this.options });
     }
 
     protected handleSetBoundsAction(action: SetBoundsAction | SetBoundsFeedbackAction): void {
@@ -108,7 +151,12 @@ export class HelperLineManager implements IActionHandler, ISelectionListener, IH
         this.feedback.dispose();
     }
 
-    getHelperLineSnapping(target: GModelElement, isSnap: boolean, direction: Direction): number {
-        return direction === Direction.Left || direction === Direction.Right ? this.snapSize.x : this.snapSize.y;
+    getMinimumMoveDelta(element: GModelElement, isSnap: boolean, direction: Direction): number {
+        if (!isSnap) {
+            return 0;
+        }
+        return direction === Direction.Left || direction === Direction.Right
+            ? this.options.minimumMoveDelta.x
+            : this.options.minimumMoveDelta.y;
     }
 }

package/src/features/helper-lines/helper-line-manager.ts

@@ -17,5 +17,12 @@ import { GModelElement } from '@eclipse-glsp/sprotty';
 import { Direction } from './model';
 
 export interface IHelperLineManager {
-    getHelperLineSnapping(target: GModelElement, isSnap: boolean, direction: Direction): number;
+    /**
+     * Calculates the minimum move delta that is necessary to break through a helper line.
+     *
+     * @param element element that is being moved
+     * @param isSnap whether snapping is active or not
+     * @param direction direction in which the target element is moving
+     */
+    getMinimumMoveDelta(element: GModelElement, isSnap: boolean, direction: Direction): number;
 }

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

@@ -195,13 +195,13 @@ export class FeedbackMoveMouseListener extends DragAwareMouseListener implements
         if (event.buttons === 0) {
             this.mouseUp(target, event);
         } else if (!this.positionUpdater.isLastDragPositionUndefined()) {
-            this.pendingMoveInitialized?.cancel();
             if (this.elementId2startPos.size === 0) {
                 this.collectStartPositions(target.root);
             }
             this._isMouseDrag = true;
             const moveAction = this.getElementMoves(target, event, false);
             if (moveAction) {
+                this.pendingMoveInitialized?.cancel();
                 result.push(moveAction);
                 result.push(cursorFeedbackAction(CursorCSS.MOVE));
                 this.tool.registerFeedback(result, this);

package/src/utils/gmodel-util.ts

@@ -31,6 +31,7 @@ import {
     TypeGuard,
     distinctAdd,
     findParentByFeature,
+    getAbsoluteBounds,
     isBoundsAware,
     isMoveable,
     isSelectable,
@@ -350,3 +351,14 @@ export function calculateDeltaBetweenPoints(target: Point, source: Point, elemen
     const adaptedDelta = { x: delta.x / zoom, y: delta.y / zoom };
     return adaptedDelta;
 }
+
+export function isVisibleOnCanvas(model: BoundsAwareModelElement): boolean {
+    const modelBounds = getAbsoluteBounds(model);
+    const canvasBounds = model.root.canvasBounds;
+    return (
+        modelBounds.x <= canvasBounds.width &&
+        modelBounds.x + modelBounds.width >= 0 &&
+        modelBounds.y <= canvasBounds.height &&
+        modelBounds.y + modelBounds.height >= 0
+    );
+}