kritzel-react 0.1.32 → 0.1.34

package/dist/kritzel-stencil/src/classes/handlers/move.handler.js

@@ -1,213 +0,0 @@
-import { KritzelEventHelper } from '../../helpers/event.helper';
-import { KritzelBaseHandler } from './base.handler';
-import { KritzelLine } from '../objects/line.class';
-/** Threshold in screen pixels for disconnecting anchored lines during drag */
-const ANCHOR_DISCONNECT_THRESHOLD = 30;
-export class KritzelMoveHandler extends KritzelBaseHandler {
-    constructor(core) {
-        super(core);
-        /** Initial position when drag started (for calculating total accumulated distance) */
-        this.initialDragX = 0;
-        this.initialDragY = 0;
-        /** Set of line IDs that have been disconnected from anchors during this drag */
-        this.disconnectedLineIds = new Set();
-        this.hasMoved = false;
-        this.trackedPointerId = null;
-    }
-    reset() {
-        this.dragStartX = 0;
-        this.dragStartY = 0;
-        this.startX = 0;
-        this.startY = 0;
-        this.endX = 0;
-        this.endY = 0;
-        this.initialDragX = 0;
-        this.initialDragY = 0;
-        this.disconnectedLineIds.clear();
-        this.hasMoved = false;
-        this.trackedPointerId = null;
-    }
-    cancelPendingDrag() {
-        this._core.store.state.isDragging = false;
-        this.reset();
-    }
-    handlePointerDown(event) {
-        if (event.pointerType === 'mouse') {
-            if (KritzelEventHelper.isLeftClick(event)) {
-                const selectionGroup = this._core.store.selectionGroup;
-                if ((selectionGroup === null || selectionGroup === void 0 ? void 0 : selectionGroup.isSelected) && !this._core.store.state.isResizeHandleSelected && !this._core.store.state.isRotationHandleSelected && !this._core.store.state.isLineHandleSelected) {
-                    const clientX = event.clientX - this._core.store.offsetX;
-                    const clientY = event.clientY - this._core.store.offsetY;
-                    this._core.store.state.isDragging = true;
-                    this.dragStartX = clientX;
-                    this.dragStartY = clientY;
-                    this.startX = this.dragStartX;
-                    this.startY = this.dragStartY;
-                    this.initialDragX = clientX;
-                    this.initialDragY = clientY;
-                    this.disconnectedLineIds.clear();
-                    this.trackedPointerId = event.pointerId;
-                }
-                else {
-                    this.trackedPointerId = null;
-                }
-            }
-            else {
-                this.trackedPointerId = null;
-            }
-        }
-        if (event.pointerType === 'touch' || event.pointerType === 'pen') {
-            const activePointers = Array.from(this._core.store.state.pointers.values());
-            if (this._core.store.state.pointers.size === 1) {
-                if (this._core.store.state.isScaling) {
-                    this.trackedPointerId = null;
-                    return;
-                }
-                const selectionGroup = this._core.store.selectionGroup;
-                if ((selectionGroup === null || selectionGroup === void 0 ? void 0 : selectionGroup.isSelected) && !this._core.store.state.isResizeHandleSelected && !this._core.store.state.isRotationHandleSelected && !this._core.store.state.isLineHandleSelected) {
-                    const x = Math.round(activePointers[0].clientX - this._core.store.offsetX);
-                    const y = Math.round(activePointers[0].clientY - this._core.store.offsetY);
-                    this.dragStartX = x;
-                    this.dragStartY = y;
-                    this.startX = x;
-                    this.startY = y;
-                    this.initialDragX = x;
-                    this.initialDragY = y;
-                    this.disconnectedLineIds.clear();
-                    this.trackedPointerId = event.pointerId;
-                }
-                else {
-                    this.trackedPointerId = null;
-                }
-            }
-        }
-    }
-    handlePointerMove(event) {
-        if (this.trackedPointerId === null || this.trackedPointerId !== event.pointerId) {
-            return;
-        }
-        if (event.pointerType === 'mouse') {
-            const selectionGroup = this._core.store.selectionGroup;
-            if (this._core.store.state.isDragging && selectionGroup) {
-                const clientX = event.clientX - this._core.store.offsetX;
-                const clientY = event.clientY - this._core.store.offsetY;
-                this.endX = clientX;
-                this.endY = clientY;
-                const moveDeltaX = Math.abs(clientX - this.startX);
-                const moveDeltaY = Math.abs(clientY - this.startY);
-                const moveThreshold = 5;
-                if (this.hasMoved || moveDeltaX > moveThreshold || moveDeltaY > moveThreshold) {
-                    // Check for anchor disconnect threshold on lines
-                    this.checkAndDisconnectAnchors(clientX, clientY);
-                    selectionGroup.move(clientX, clientY, this.dragStartX, this.dragStartY);
-                    this.dragStartX = clientX;
-                    this.dragStartY = clientY;
-                    this.hasMoved = true;
-                }
-            }
-        }
-        if (event.pointerType === 'touch' || event.pointerType === 'pen') {
-            const activePointers = Array.from(this._core.store.state.pointers.values());
-            const selectionGroup = this._core.store.selectionGroup;
-            if (this._core.store.state.pointers.size === 1 &&
-                selectionGroup &&
-                !this._core.store.state.isResizeHandleSelected &&
-                !this._core.store.state.isRotationHandleSelected &&
-                !this._core.store.state.isScaling) {
-                const x = Math.round(activePointers[0].clientX - this._core.store.offsetX);
-                const y = Math.round(activePointers[0].clientY - this._core.store.offsetY);
-                this._core.store.state.isDragging = true;
-                this.endX = x;
-                this.endY = y;
-                const moveDeltaX = Math.abs(x - this.startX);
-                const moveDeltaY = Math.abs(y - this.startY);
-                const moveThreshold = 5;
-                if (this.hasMoved || moveDeltaX > moveThreshold || moveDeltaY > moveThreshold) {
-                    clearTimeout(this._core.store.state.longTouchTimeout);
-                    // Check for anchor disconnect threshold on lines
-                    this.checkAndDisconnectAnchors(x, y);
-                    selectionGroup.move(x, y, this.dragStartX, this.dragStartY);
-                    this.dragStartX = x;
-                    this.dragStartY = y;
-                    this.hasMoved = true;
-                }
-            }
-        }
-    }
-    handlePointerUp(event) {
-        if (this.trackedPointerId === null || this.trackedPointerId !== event.pointerId) {
-            return;
-        }
-        if (event.pointerType === 'mouse') {
-            if (this._core.store.state.isDragging) {
-                this._core.store.state.isDragging = false;
-                if (this.hasMoved) {
-                    this._core.store.selectionGroup.update();
-                    this._core.engine.emitObjectsChange();
-                    this._core.store.state.hasObjectsChanged = true;
-                }
-            }
-        }
-        if (event.pointerType === 'touch' || event.pointerType === 'pen') {
-            if (this._core.store.state.isDragging) {
-                this._core.store.state.isDragging = false;
-                if (this.hasMoved) {
-                    this._core.store.selectionGroup.update();
-                    this._core.engine.emitObjectsChange();
-                    this._core.store.state.hasObjectsChanged = true;
-                }
-            }
-        }
-        this.reset();
-    }
-    /**
-     * Checks if the total accumulated drag distance exceeds the anchor disconnect threshold.
-     * If so, disconnects all anchors from any KritzelLine objects in the selection group.
-     * This allows anchored lines to be freely moved after dragging beyond the threshold.
-     */
-    checkAndDisconnectAnchors(currentX, currentY) {
-        const totalDeltaX = currentX - this.initialDragX;
-        const totalDeltaY = currentY - this.initialDragY;
-        const totalDistance = Math.sqrt(totalDeltaX * totalDeltaX + totalDeltaY * totalDeltaY);
-        if (totalDistance < ANCHOR_DISCONNECT_THRESHOLD) {
-            return;
-        }
-        const selectionGroup = this._core.store.selectionGroup;
-        if (!selectionGroup) {
-            return;
-        }
-        // Only disconnect lines if the selection group contains ONLY lines.
-        // If moving lines with other objects (e.g. shapes they might be anchored to), prevent auto-disconnect.
-        // Cache objects once to avoid repeated getter calls
-        const children = selectionGroup.objects;
-        const onlyLines = children.every(obj => obj instanceof KritzelLine);
-        if (!onlyLines) {
-            return;
-        }
-        // Find and disconnect anchors from all anchored lines in the selection
-        for (const obj of children) {
-            // Skip if already disconnected in this drag session
-            if (this.disconnectedLineIds.has(obj.id)) {
-                continue;
-            }
-            // Check if this is a line with anchors
-            if (obj instanceof KritzelLine) {
-                const line = obj;
-                const hasAnchors = line.startAnchor || line.endAnchor;
-                if (hasAnchors) {
-                    // Disconnect both anchors
-                    if (line.startAnchor) {
-                        this._core.anchorManager.removeAnchor(line.id, 'start');
-                    }
-                    if (line.endAnchor) {
-                        this._core.anchorManager.removeAnchor(line.id, 'end');
-                    }
-                    // Mark as disconnected so we don't try again
-                    this.disconnectedLineIds.add(line.id);
-                    // Update the line to persist the change
-                    this._core.store.state.objects.update(line);
-                }
-            }
-        }
-    }
-}

package/dist/kritzel-stencil/src/classes/handlers/resize.handler.js

@@ -1,205 +0,0 @@
-import { KritzelHandleType } from '../../enums/handle-type.enum';
-import { KritzelEventHelper } from '../../helpers/event.helper';
-import { KritzelBaseHandler } from './base.handler';
-export class KritzelResizeHandler extends KritzelBaseHandler {
-    constructor(core) {
-        super(core);
-        this.initialMouseX = 0;
-        this.initialMouseY = 0;
-        this.initialSize = { x: 0, y: 0, width: 0, height: 0 };
-        this.newSize = { x: 0, y: 0, width: 0, height: 0 };
-        this.hasResized = false;
-    }
-    reset() {
-        this.initialMouseX = 0;
-        this.initialMouseY = 0;
-        this.initialSize = { x: 0, y: 0, width: 0, height: 0 };
-        this.newSize = { x: 0, y: 0, width: 0, height: 0 };
-        this.hasResized = false;
-    }
-    handlePointerDown(event) {
-        if (event.pointerType === 'mouse') {
-            if (KritzelEventHelper.isLeftClick(event)) {
-                const selectionGroup = this._core.store.selectionGroup;
-                if (selectionGroup && this._core.store.state.isResizeHandleSelected) {
-                    const clientX = event.clientX - this._core.store.offsetX;
-                    const clientY = event.clientY - this._core.store.offsetY;
-                    this._core.store.state.isResizing = true;
-                    this.initialMouseX = clientX;
-                    this.initialMouseY = clientY;
-                    this.initialSize.width = selectionGroup.width;
-                    this.initialSize.height = selectionGroup.height;
-                    this.initialSize.x = selectionGroup.translateX;
-                    this.initialSize.y = selectionGroup.translateY;
-                }
-            }
-        }
-        if (event.pointerType === 'touch' || event.pointerType === 'pen') {
-            const activePointers = Array.from(this._core.store.state.pointers.values());
-            const firstTouch = activePointers[0];
-            if (!firstTouch) {
-                return;
-            }
-            if (activePointers.length === 1) {
-                const selectionGroup = this._core.store.selectionGroup;
-                if (selectionGroup && this._core.store.state.isResizeHandleSelected) {
-                    const clientX = Math.round(firstTouch.clientX - this._core.store.offsetX);
-                    const clientY = Math.round(firstTouch.clientY - this._core.store.offsetY);
-                    this._core.store.state.isResizing = true;
-                    this.initialMouseX = clientX;
-                    this.initialMouseY = clientY;
-                    this.initialSize.width = selectionGroup.width;
-                    this.initialSize.height = selectionGroup.height;
-                    this.initialSize.x = selectionGroup.translateX;
-                    this.initialSize.y = selectionGroup.translateY;
-                    clearTimeout(this._core.store.state.longTouchTimeout);
-                }
-            }
-        }
-    }
-    handlePointerMove(event) {
-        if (event.pointerType === 'mouse') {
-            const selectionGroup = this._core.store.selectionGroup;
-            if (this._core.store.state.isResizing && selectionGroup) {
-                const clientX = event.clientX - this._core.store.offsetX;
-                const clientY = event.clientY - this._core.store.offsetY;
-                const dx = clientX - this.initialMouseX;
-                const dy = clientY - this.initialMouseY;
-                const resizeDeltaX = Math.abs(dx);
-                const resizeDeltaY = Math.abs(dy);
-                const resizeThreshold = 5;
-                if (resizeDeltaX > resizeThreshold || resizeDeltaY > resizeThreshold) {
-                    this.hasResized = true;
-                }
-                if (!this.hasResized) {
-                    return;
-                }
-                const rotation = selectionGroup.rotation;
-                const sin = Math.sin(rotation);
-                const cos = Math.cos(rotation);
-                const objectScale = selectionGroup.scale || 1;
-                const currentScale = this._core.store.state.scale;
-                // Calculate delta in local unrotated space
-                // We rotate the screen delta by -rotation to align with the object's axes
-                const localDx = (dx * cos + dy * sin) / currentScale;
-                const localDy = (-dx * sin + dy * cos) / currentScale;
-                // Calculate the center of the selection group before resize
-                const initialCenterX = this.initialSize.x + this.initialSize.width / objectScale / 2;
-                const initialCenterY = this.initialSize.y + this.initialSize.height / objectScale / 2;
-                // The center moves by half of the screen delta (scaled)
-                // This is true regardless of rotation because the resize happens symmetrically around the center
-                // relative to the fixed point logic
-                const newCenterX = initialCenterX + dx / currentScale / 2;
-                const newCenterY = initialCenterY + dy / currentScale / 2;
-                switch (this._core.store.state.resizeHandleType) {
-                    case KritzelHandleType.TopLeft:
-                        this.newSize.width = this.initialSize.width - localDx * objectScale;
-                        this.newSize.height = this.initialSize.height - localDy * objectScale;
-                        break;
-                    case KritzelHandleType.TopRight:
-                        this.newSize.width = this.initialSize.width + localDx * objectScale;
-                        this.newSize.height = this.initialSize.height - localDy * objectScale;
-                        break;
-                    case KritzelHandleType.BottomLeft:
-                        this.newSize.width = this.initialSize.width - localDx * objectScale;
-                        this.newSize.height = this.initialSize.height + localDy * objectScale;
-                        break;
-                    case KritzelHandleType.BottomRight:
-                        this.newSize.width = this.initialSize.width + localDx * objectScale;
-                        this.newSize.height = this.initialSize.height + localDy * objectScale;
-                        break;
-                }
-                this.newSize.x = newCenterX - this.newSize.width / objectScale / 2;
-                this.newSize.y = newCenterY - this.newSize.height / objectScale / 2;
-                selectionGroup.resize(this.newSize.x, this.newSize.y, this.newSize.width, this.newSize.height);
-            }
-        }
-        if (event.pointerType === 'touch' || event.pointerType === 'pen') {
-            const activePointers = Array.from(this._core.store.state.pointers.values());
-            const oneFingerTouch = activePointers[0];
-            if (!oneFingerTouch) {
-                return;
-            }
-            const selectionGroup = this._core.store.selectionGroup;
-            if (this._core.store.state.isResizing && selectionGroup) {
-                const clientX = Math.round(oneFingerTouch.clientX - this._core.store.offsetX);
-                const clientY = Math.round(oneFingerTouch.clientY - this._core.store.offsetY);
-                const dx = clientX - this.initialMouseX;
-                const dy = clientY - this.initialMouseY;
-                const resizeDeltaX = Math.abs(dx);
-                const resizeDeltaY = Math.abs(dy);
-                const resizeThreshold = 5;
-                if (resizeDeltaX > resizeThreshold || resizeDeltaY > resizeThreshold) {
-                    clearTimeout(this._core.store.state.longTouchTimeout);
-                    this.hasResized = true;
-                }
-                if (!this.hasResized) {
-                    return;
-                }
-                const rotation = selectionGroup.rotation;
-                const sin = Math.sin(rotation);
-                const cos = Math.cos(rotation);
-                const objectScale = selectionGroup.scale || 1;
-                const currentScale = this._core.store.state.scale;
-                // Calculate delta in local unrotated space
-                // We rotate the screen delta by -rotation to align with the object's axes
-                const localDx = (dx * cos + dy * sin) / currentScale;
-                const localDy = (-dx * sin + dy * cos) / currentScale;
-                // Calculate the center of the selection group before resize
-                const initialCenterX = this.initialSize.x + this.initialSize.width / objectScale / 2;
-                const initialCenterY = this.initialSize.y + this.initialSize.height / objectScale / 2;
-                // The center moves by half of the screen delta (scaled)
-                // This is true regardless of rotation because the resize happens symmetrically around the center
-                // relative to the fixed point logic
-                const newCenterX = initialCenterX + dx / currentScale / 2;
-                const newCenterY = initialCenterY + dy / currentScale / 2;
-                switch (this._core.store.state.resizeHandleType) {
-                    case KritzelHandleType.TopLeft:
-                        this.newSize.width = this.initialSize.width - localDx * objectScale;
-                        this.newSize.height = this.initialSize.height - localDy * objectScale;
-                        break;
-                    case KritzelHandleType.TopRight:
-                        this.newSize.width = this.initialSize.width + localDx * objectScale;
-                        this.newSize.height = this.initialSize.height - localDy * objectScale;
-                        break;
-                    case KritzelHandleType.BottomLeft:
-                        this.newSize.width = this.initialSize.width - localDx * objectScale;
-                        this.newSize.height = this.initialSize.height + localDy * objectScale;
-                        break;
-                    case KritzelHandleType.BottomRight:
-                        this.newSize.width = this.initialSize.width + localDx * objectScale;
-                        this.newSize.height = this.initialSize.height + localDy * objectScale;
-                        break;
-                }
-                this.newSize.x = newCenterX - this.newSize.width / objectScale / 2;
-                this.newSize.y = newCenterY - this.newSize.height / objectScale / 2;
-                selectionGroup.resize(this.newSize.x, this.newSize.y, this.newSize.width, this.newSize.height);
-            }
-        }
-    }
-    handlePointerUp(event) {
-        if (event.pointerType === 'mouse') {
-            if (this._core.store.state.isResizing) {
-                this._core.store.state.isResizing = false;
-                if (this.hasResized) {
-                    this._core.store.selectionGroup.update();
-                    this._core.engine.emitObjectsChange();
-                    this._core.store.state.hasObjectsChanged = true;
-                }
-                this.reset();
-            }
-        }
-        if (event.pointerType === 'touch' || event.pointerType === 'pen') {
-            if (this._core.store.state.isResizing) {
-                this._core.store.state.isResizing = false;
-                if (this.hasResized) {
-                    this._core.store.selectionGroup.update();
-                    this._core.engine.emitObjectsChange();
-                    this._core.store.state.hasObjectsChanged = true;
-                }
-                this.reset();
-                clearTimeout(this._core.store.state.longTouchTimeout);
-            }
-        }
-    }
-}

package/dist/kritzel-stencil/src/classes/handlers/rotation.handler.js

@@ -1,117 +0,0 @@
-import { KritzelEventHelper } from '../../helpers/event.helper';
-import { KritzelBaseHandler } from './base.handler';
-export class KritzelRotationHandler extends KritzelBaseHandler {
-    constructor(core) {
-        super(core);
-        this.initialRotation = 0;
-        this.rotation = 0;
-        this.initialSelectionGroupRotation = 0;
-    }
-    reset() {
-        this.initialRotation = 0;
-        this.rotation = 0;
-    }
-    handlePointerDown(event) {
-        if (event.pointerType === 'mouse') {
-            if (KritzelEventHelper.isLeftClick(event)) {
-                const selectionGroup = this._core.store.selectionGroup;
-                if (selectionGroup && this._core.store.state.isRotationHandleSelected) {
-                    selectionGroup.beginTransform();
-                    const clientX = event.clientX - this._core.store.offsetX;
-                    const clientY = event.clientY - this._core.store.offsetY;
-                    this._core.store.state.isRotating = true;
-                    const objectScale = selectionGroup.scale || 1;
-                    const centerX = selectionGroup.translateX + selectionGroup.width / 2 / objectScale;
-                    const centerY = selectionGroup.translateY + selectionGroup.height / 2 / objectScale;
-                    const cursorX = (clientX - this._core.store.state.translateX) / this._core.store.state.scale;
-                    const cursorY = (clientY - this._core.store.state.translateY) / this._core.store.state.scale;
-                    this.initialSelectionGroupRotation = selectionGroup.rotation;
-                    this.initialRotation = Math.atan2(centerY - cursorY, centerX - cursorX) - selectionGroup.rotation;
-                }
-            }
-        }
-        if (event.pointerType === 'touch' || event.pointerType === 'pen') {
-            const activePointers = Array.from(this._core.store.state.pointers.values());
-            const firstTouch = activePointers[0];
-            if (!firstTouch) {
-                return;
-            }
-            if (activePointers.length === 1) {
-                const selectionGroup = this._core.store.selectionGroup;
-                if (selectionGroup && this._core.store.state.isRotationHandleSelected) {
-                    selectionGroup.beginTransform();
-                    const clientX = Math.round(firstTouch.clientX - this._core.store.offsetX);
-                    const clientY = Math.round(firstTouch.clientY - this._core.store.offsetY);
-                    this._core.store.state.isRotating = true;
-                    const objectScale = selectionGroup.scale || 1;
-                    const centerX = selectionGroup.translateX + selectionGroup.width / 2 / objectScale;
-                    const centerY = selectionGroup.translateY + selectionGroup.height / 2 / objectScale;
-                    const cursorX = (clientX - this._core.store.state.translateX) / this._core.store.state.scale;
-                    const cursorY = (clientY - this._core.store.state.translateY) / this._core.store.state.scale;
-                    this.initialSelectionGroupRotation = selectionGroup.rotation;
-                    this.initialRotation = Math.atan2(centerY - cursorY, centerX - cursorX) - selectionGroup.rotation;
-                    clearTimeout(this._core.store.state.longTouchTimeout);
-                }
-            }
-        }
-    }
-    handlePointerMove(event) {
-        if (event.pointerType === 'mouse') {
-            const selectionGroup = this._core.store.selectionGroup;
-            if (this._core.store.state.isRotating && selectionGroup) {
-                const clientX = event.clientX - this._core.store.offsetX;
-                const clientY = event.clientY - this._core.store.offsetY;
-                const objectScale = selectionGroup.scale || 1;
-                const groupCenterX = selectionGroup.translateX + selectionGroup.width / 2 / objectScale;
-                const groupCenterY = selectionGroup.translateY + selectionGroup.height / 2 / objectScale;
-                const cursorX = (clientX - this._core.store.state.translateX) / this._core.store.state.scale;
-                const cursorY = (clientY - this._core.store.state.translateY) / this._core.store.state.scale;
-                const currentRotation = Math.atan2(groupCenterY - cursorY, groupCenterX - cursorX);
-                this.rotation = currentRotation - this.initialRotation;
-                selectionGroup.rotate(this.rotation);
-            }
-        }
-        if (event.pointerType === 'touch' || event.pointerType === 'pen') {
-            const activePointers = Array.from(this._core.store.state.pointers.values());
-            const firstTouch = activePointers[0];
-            if (!firstTouch) {
-                return;
-            }
-            const selectionGroup = this._core.store.selectionGroup;
-            if (this._core.store.state.isRotating && selectionGroup) {
-                const clientX = Math.round(firstTouch.clientX - this._core.store.offsetX);
-                const clientY = Math.round(firstTouch.clientY - this._core.store.offsetY);
-                const objectScale = selectionGroup.scale || 1;
-                const groupCenterX = selectionGroup.translateX + selectionGroup.width / 2 / objectScale;
-                const groupCenterY = selectionGroup.translateY + selectionGroup.height / 2 / objectScale;
-                const cursorX = (clientX - this._core.store.state.translateX) / this._core.store.state.scale;
-                const cursorY = (clientY - this._core.store.state.translateY) / this._core.store.state.scale;
-                const currentRotation = Math.atan2(groupCenterY - cursorY, groupCenterX - cursorX);
-                this.rotation = currentRotation - this.initialRotation;
-                selectionGroup.rotate(this.rotation);
-                clearTimeout(this._core.store.state.longTouchTimeout);
-            }
-        }
-    }
-    handlePointerUp(event) {
-        if (event.pointerType === 'mouse') {
-            if (this._core.store.state.isRotating) {
-                this._core.store.selectionGroup.update();
-                this._core.engine.emitObjectsChange();
-                this._core.store.state.isRotating = false;
-                this._core.store.state.hasObjectsChanged = true;
-                this.reset();
-            }
-        }
-        if (event.pointerType === 'touch' || event.pointerType === 'pen') {
-            if (this._core.store.state.isRotating) {
-                this._core.store.selectionGroup.update();
-                this._core.engine.emitObjectsChange();
-                this._core.store.state.isRotating = false;
-                this._core.store.state.hasObjectsChanged = true;
-                this.reset();
-                clearTimeout(this._core.store.state.longTouchTimeout);
-            }
-        }
-    }
-}