kritzel-react 0.1.30 → 0.1.32

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

@@ -0,0 +1,213 @@
+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

@@ -0,0 +1,205 @@
+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

@@ -0,0 +1,117 @@
+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);
+            }
+        }
+    }
+}