Skip to content

Build your own AI office with Univer Office SDK. Bring editing, calculation, collaboration, and file processing into your product for people and AI agents. Built on an extensible open-source core.

55.6 KB
Raw Blame
/**
 * Copyright 2023-present DreamNum Co., Ltd.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

import type { IFreeze, IRange, Nullable, Workbook } from '@univerjs/core';
import type { IMouseEvent, IPoint, IPointerEvent, IRenderContext, IRenderModule, IScrollObserverParam } from '@univerjs/engine-render';
import type { IScrollToCellOperationParams, ISheetSkeletonManagerParam } from '@univerjs/sheets';
import type { Subscription } from 'rxjs';
import {
    Direction,
    Disposable,
    ICommandService,
    IContextService,
    Inject,
    IUniverInstanceService,
    RANGE_TYPE,
    toDisposable,
} from '@univerjs/core';
import { DeviceType, DrawingGroupObject, IRenderManagerService, ObjectType, Scene, SHEET_VIEWPORT_KEY, Vector2 } from '@univerjs/engine-render';
import { ScrollToCellOperation, SheetsSelectionsService } from '@univerjs/sheets';
import { MobileZoomIndicator } from '@univerjs/ui';
import { take } from 'rxjs';
import type { IExpandSelectionCommandParams } from '../../../commands/commands/set-selection.command';
import type { IScrollState, IScrollStateSearchParam, IViewportScrollState } from '../../../services/scroll-manager.service';
import { ScrollCommand, SetScrollRelativeCommand } from '../../../commands/commands/set-scroll.command';
import { ExpandSelectionCommand, MoveSelectionCommand, MoveSelectionEnterAndTabCommand } from '../../../commands/commands/set-selection.command';
import { SetZoomRatioCommand } from '../../../commands/commands/set-zoom-ratio.command';
import { MOBILE_EXPANDING_SELECTION, MOBILE_PINCH_ZOOMING } from '../../../consts/mobile-context';
import { SheetScrollManagerService } from '../../../services/scroll-manager.service';
import { SheetSkeletonManagerService } from '../../../services/sheet-skeleton-manager.service';
import { getSheetObject } from '../../utils/component-tools';

const TOUCH_CROSS_AXIS_LOCK_RATIO = 2;
const SHEET_NAVIGATION_COMMANDS = [MoveSelectionCommand.id, MoveSelectionEnterAndTabCommand.id];
const SHEET_DRAWING_OBJECT_TYPES = [ObjectType.IMAGE, ObjectType.SHAPE, ObjectType.CHART, ObjectType.DRAWING_DOM];

interface IMobileTouchEvent {
    touches: ArrayLike<Pick<Touch, 'clientX' | 'clientY'>>;
    preventDefault(): void;
}

/**
 * This controller handles scroll logic in sheet interaction.
 */
export class MobileSheetsScrollRenderController extends Disposable implements IRenderModule {
    constructor(
        private readonly _context: IRenderContext<Workbook>,
        @Inject(SheetSkeletonManagerService) private readonly _sheetSkeletonManagerService: SheetSkeletonManagerService,
        @ICommandService private readonly _commandService: ICommandService,
        @IRenderManagerService private readonly _renderManagerService: IRenderManagerService,
        @Inject(SheetsSelectionsService) private readonly _selectionManagerService: SheetsSelectionsService,
        @Inject(SheetScrollManagerService) private readonly _scrollManagerService: SheetScrollManagerService,
        @IUniverInstanceService protected readonly _univerInstanceService: IUniverInstanceService,
        @IContextService private readonly _contextService: IContextService
    ) {
        super();

        this._init();
    }

    scrollToRange(range: IRange): boolean {
        let { endRow, endColumn, startColumn, startRow } = range;
        const bounding = this._getViewportBounding();
        if (range.rangeType === RANGE_TYPE.ROW) {
            startColumn = 0;
            endColumn = 0;
        } else if (range.rangeType === RANGE_TYPE.COLUMN) {
            startRow = 0;
            endRow = 0;
        }

        if (bounding) {
            const row = bounding.startRow > endRow ? startRow : endRow;
            const col = bounding.startColumn > endColumn ? startColumn : endColumn;
            return this._scrollToCell(row, col);
        } else {
            return this._scrollToCell(startRow, startColumn);
        }
    }

    private _init() {
        this._initCommandListener();
        this._initScrollEventListener();
        this._initPointerScrollEvent();
        this._initSkeletonListener();
    }

    private _initCommandListener(): void {
        this.disposeWithMe(
            this._commandService.onCommandExecuted((command) => {
                if (SHEET_NAVIGATION_COMMANDS.includes(command.id)) {
                    this._scrollToSelection();
                } else if (command.id === ScrollToCellOperation.id) {
                    const param = (command.params as IScrollToCellOperationParams).range;
                    this.scrollToRange(param);
                } else if (command.id === ExpandSelectionCommand.id) {
                    const param = command.params as IExpandSelectionCommandParams;
                    this._scrollToSelectionForExpand(param);
                }
            })
        );
    }

    private _scrollToSelectionForExpand(param: IExpandSelectionCommandParams) {
        setTimeout(() => {
            const selection = this._selectionManagerService.getCurrentLastSelection();
            if (selection == null) {
                return;
            }

            const { startRow, startColumn, endRow, endColumn } = selection.range;

            const bounds = this._getViewportBounding();
            if (bounds == null) {
                return;
            }

            const { startRow: viewportStartRow, startColumn: viewportStartColumn, endRow: viewportEndRow, endColumn: viewportEndColumn } = bounds;

            let row = 0;
            let column = 0;

            if (startRow > viewportStartRow) {
                row = endRow;
            } else if (endRow < viewportEndRow) {
                row = startRow;
            } else {
                row = viewportStartRow;
            }

            if (startColumn > viewportStartColumn) {
                column = endColumn;
            } else if (endColumn < viewportEndColumn) {
                column = startColumn;
            } else {
                column = viewportStartColumn;
            }

            if (param.direction === Direction.DOWN) {
                row = endRow;
            } else if (param.direction === Direction.UP) {
                row = startRow;
            } else if (param.direction === Direction.RIGHT) {
                column = endColumn;
            } else if (param.direction === Direction.LEFT) {
                column = startColumn;
            }

            this._scrollToCell(row, column);
        }, 0);
    }

    private _getFreeze(): Nullable<IFreeze> {
        return this._sheetSkeletonManagerService.getCurrentParam()?.skeleton.worksheet.getFreeze();
    }

    // eslint-disable-next-line max-lines-per-function
    private _initScrollEventListener() {
        const { scene } = this._context;
        if (scene == null) return;

        const viewportMain = scene.getViewport(SHEET_VIEWPORT_KEY.VIEW_MAIN);
        if (!viewportMain) return;

        //#region scrollInfo$ subscriber ---> viewport.scrollTo
        this.disposeWithMe(
            toDisposable(
                // wheel event --> set-scroll.command('sheet.operation.set-scroll') --> scroll.operation.ts -->
                // scrollManagerService.setScrollInfoAndEmitEvent --->  scrollManagerService.setScrollInfo(raw value, may be negative) &&
                // _notifyCurrentScrollInfo
                this._scrollManagerService.rawScrollInfo$.subscribe((rawScrollInfo: Nullable<IScrollState>) => {
                    if (rawScrollInfo == null) {
                        viewportMain.scrollToViewportPos({
                            viewportScrollX: 0,
                            viewportScrollY: 0,
                        });
                        return;
                    }

                    const skeleton = this._sheetSkeletonManagerService.getCurrentParam()?.skeleton;
                    if (!skeleton) return;

                    // data source: scroll-manager.service.ts@_scrollInfo
                    const { sheetViewStartRow, sheetViewStartColumn, offsetX, offsetY } = rawScrollInfo;

                    const { startX, startY } = skeleton.getCellWithCoordByIndex(
                        sheetViewStartRow,
                        sheetViewStartColumn,
                        false
                    );

                    // viewportScrollXByEvent is not same as viewportScrollX, by event, the value may be negative, or over max
                    const viewportScrollX = startX + offsetX;
                    const viewportScrollY = startY + offsetY;

                    // const config = viewportMain.transViewportScroll2ScrollValue(viewportScrollXByEvent, viewportScrollYByEvent);
                    viewportMain.scrollToViewportPos({ viewportScrollX, viewportScrollY });
                })
            )
        );
        //#endregion

        //#region viewport.onScrollAfter$ --> setScrollInfoToCurrSheet & validViewportScrollInfo$
        this.disposeWithMe(
            viewportMain.onScrollAfter$.subscribeEvent((scrollAfterParam: IScrollObserverParam) => {
                if (!scrollAfterParam) return;
                const skeleton = this._sheetSkeletonManagerService.getCurrentParam()?.skeleton;
                if (skeleton == null) return;
                const sheetObject = this._getSheetObject();
                if (skeleton == null || sheetObject == null) return;

                const { viewportScrollX, viewportScrollY, scrollX, scrollY } = scrollAfterParam;

                // according to the actual scroll position, the most suitable row, column and offset combination is recalculated.
                const { row, column, rowOffset, columnOffset } = skeleton.getOffsetRelativeToRowCol(
                    viewportScrollX,
                    viewportScrollY
                );

                const scrollInfo: IViewportScrollState = {
                    sheetViewStartRow: row,
                    sheetViewStartColumn: column,
                    offsetX: columnOffset,
                    offsetY: rowOffset,
                    viewportScrollX,
                    viewportScrollY,
                    scrollX,
                    scrollY,
                };
                // lastestScrollInfo derived from viewportScrollX, viewportScrollY from onScrollAfter$
                this._scrollManagerService.setValidScrollStateToCurrSheet(scrollInfo);
                this._scrollManagerService.validViewportScrollInfo$.next({
                    ...scrollInfo,
                    scrollX,
                    scrollY,
                    viewportScrollX,
                    viewportScrollY,
                });
                // snapshot is diff by diff people!
                // this._scrollManagerService.setScrollInfoToSnapshot({ ...lastestScrollInfo, viewportScrollX, viewportScrollY });
            })
        );
        //#endregion

        //#region scroll by bar
        this.disposeWithMe(
            viewportMain.onScrollByBar$.subscribeEvent((param) => {
                const skeleton = this._sheetSkeletonManagerService.getCurrentParam()?.skeleton;
                if (skeleton == null || param.isTrigger === false || (param.isBarDragging && !param.isBarDragEnd)) {
                    return;
                }

                const sheetObject = this._getSheetObject();
                if (skeleton == null || sheetObject == null) {
                    return;
                }
                const { viewportScrollX = 0, viewportScrollY = 0 } = param;

                const freeze = this._getFreeze();

                const { row, column, rowOffset, columnOffset } = skeleton.getOffsetRelativeToRowCol(
                    viewportScrollX,
                    viewportScrollY
                );

                this._commandService.executeCommand(ScrollCommand.id, {
                    sheetViewStartRow: row + (freeze?.ySplit || 0),
                    sheetViewStartColumn: column + (freeze?.xSplit || 0),
                    offsetX: columnOffset,
                    offsetY: rowOffset,
                });
            })
        );
        //#endregion
    }

    private _initSkeletonListener() {
        this.disposeWithMe(toDisposable(
            this._sheetSkeletonManagerService.currentSkeletonBefore$.subscribe((param) => {
                if (param == null) {
                    return;
                }
                const scrollParam = { unitId: param.unitId, sheetId: param.sheetId } as IScrollStateSearchParam;
                this._scrollManagerService.setSearchParam(scrollParam);
                const sheetObject = this._getSheetObject();
                if (!sheetObject) return;
                const scene = sheetObject.scene;
                const viewportMain = scene.getViewport(SHEET_VIEWPORT_KEY.VIEW_MAIN);
                const currScrollInfo = this._scrollManagerService.getScrollStateByParam(scrollParam);
                const { viewportScrollX, viewportScrollY } = this._scrollManagerService.calcViewportScrollFromRowColOffset(currScrollInfo as unknown as Nullable<IViewportScrollState>);
                if (viewportMain) {
                    if (currScrollInfo) {
                        viewportMain.viewportScrollX = viewportScrollX;
                        viewportMain.viewportScrollY = viewportScrollY;
                    } else {
                        viewportMain.viewportScrollX = 0;
                        viewportMain.viewportScrollY = 0;
                    }
                    this._updateSceneSize(param as unknown as ISheetSkeletonManagerParam);
                }
            })
        ));
    }

    /**
     * for mobile - iOS-like smooth inertia scrolling
     * Uses native touch events for better mobile experience while keeping onPointerDown$ as trigger
     * to avoid interfering with header events
     */
    // eslint-disable-next-line max-lines-per-function
    private _initPointerScrollEvent() {
        const sheetObject = this._getSheetObject();
        if (!sheetObject) return;

        const scene = sheetObject.scene;
        const spreadsheet = sheetObject.spreadsheet;
        const transformer = scene.getTransformerByCreate();
        const moveOnlyWhenSelected = transformer.moveOnlyWhenSelected;
        transformer.resetProps({ moveOnlyWhenSelected: true });
        this.disposeWithMe(toDisposable(() => transformer.resetProps({ moveOnlyWhenSelected })));
        const viewportMain = scene.getViewport(SHEET_VIEWPORT_KEY.VIEW_MAIN);
        const engine = scene.getEngine();
        const lastTouchPos: IPoint = { x: 0, y: 0 };
        let _touchScrolling: boolean = false;
        let _drawingTransforming: boolean = false;

        // Velocity tracking for smooth inertia (iOS-like)
        const velocity = { x: 0, y: 0 };
        let scrollInertiaAnimationID: null | number = null;
        let inertiaFrameSubscription: Subscription | null = null;
        let inertiaMotion: {
            startTime: number;
            duration: number;
            sheetId: string;
            velocityX: number;
            velocityY: number;
            distanceX: number;
            distanceY: number;
        } | null = null;

        // Track velocity history for smoother calculation (like iOS)
        const VELOCITY_HISTORY_SIZE = 5;
        const velocityHistory: Array<{ x: number; y: number; time: number }> = [];
        let lastMoveTime = 0;

        // Track swipe characteristics for dynamic inertia calculation
        let swipeStartTime = 0;
        let swipeTotalDisplacement = { x: 0, y: 0 };

        // iOS-like physics constants (tuned for smoother feel)
        const BASE_DECELERATION_RATE = 0.992; // Per millisecond deceleration (lower = stops faster)
        const BASE_MIN_VELOCITY_THRESHOLD = 0.22; // Minimum velocity to continue animation
        const BASE_MAX_VELOCITY = 12; // Cap maximum velocity for stability
        // Keep the established 60Hz fling distance while integrating independently of frame intervals.
        const INERTIA_DISTANCE_SCALE = BASE_DECELERATION_RATE ** (1000 / 60);

        // Flick detection thresholds
        const FLICK_TIME_THRESHOLD = 240; // ms - swipes faster than this are considered "flicks"
        const FLICK_DISTANCE_THRESHOLD = 30; // px - minimum distance to be considered a flick
        const MIN_VELOCITY_MULTIPLIER = 0.05; // For slow drags
        const MAX_VELOCITY_MULTIPLIER = 0.26; // For quick flicks

        /**
         * Get current zoom ratio for adjusting physics parameters
         */
        const getCurrentZoomRatio = (): number => {
            const worksheet = this._context.unit.getActiveSheet();
            return worksheet?.getZoomRatio() || 1;
        };

        /**
         * Get physics parameters for inertia scrolling
         * These are now zoom-independent since zoom adjustment is applied at the delta level
         * This ensures consistent scroll behavior at any zoom level
         */
        const getZoomAdjustedParams = () => {
            // Use base values directly - zoom adjustment is handled in touchmove delta calculation
            return {
                decelerationRate: BASE_DECELERATION_RATE,
                minVelocityThreshold: BASE_MIN_VELOCITY_THRESHOLD,
                maxVelocity: BASE_MAX_VELOCITY,
            };
        };

        /**
         * Calculate dynamic velocity multiplier based on swipe characteristics
         * Quick short flicks get higher multiplier, slow drags get lower multiplier
         */
        const calculateDynamicVelocityMultiplier = (
            swipeDuration: number,
            swipeDistance: number,
            instantVelocity: number
        ): number => {
            // Calculate swipe speed (distance / time)
            const swipeSpeed = swipeDuration > 0 ? swipeDistance / swipeDuration : 0;

            // Detect if this is a "flick" gesture (quick, intentional swipe)
            const isFlick = swipeDuration < FLICK_TIME_THRESHOLD && swipeDistance > FLICK_DISTANCE_THRESHOLD;

            // Base multiplier calculation
            let multiplier: number;

            if (isFlick) {
                // Quick flick: use higher multiplier based on speed
                // Faster flicks get closer to MAX_VELOCITY_MULTIPLIER
                const speedFactor = Math.min(swipeSpeed / 2, 1); // Normalize speed (2 px/ms = fast)
                multiplier = MIN_VELOCITY_MULTIPLIER + (MAX_VELOCITY_MULTIPLIER - MIN_VELOCITY_MULTIPLIER) * speedFactor;

                // Boost multiplier for very quick flicks with high instantaneous velocity
                if (swipeDuration < 150 && Math.abs(instantVelocity) > 3) {
                    multiplier *= 1.3;
                }
            } else {
                // Slow drag: use lower multiplier, but still proportional to final velocity
                const velocityFactor = Math.min(Math.abs(instantVelocity) / 5, 1);
                multiplier = MIN_VELOCITY_MULTIPLIER * (0.5 + velocityFactor * 0.5);
            }

            // Clamp the multiplier
            return Math.max(MIN_VELOCITY_MULTIPLIER * 0.5, Math.min(MAX_VELOCITY_MULTIPLIER * 1.5, multiplier));
        };

        /**
         * Calculate weighted average velocity from history (iOS-like behavior)
         * More recent samples have higher weight
         */
        const calculateAverageVelocity = (): { x: number; y: number } => {
            if (velocityHistory.length === 0) {
                return { x: 0, y: 0 };
            }

            let totalWeight = 0;
            let weightedVelX = 0;
            let weightedVelY = 0;

            // Give more weight to recent velocity samples
            for (let i = 0; i < velocityHistory.length; i++) {
                const weight = (i + 1) * (i + 1); // Quadratic weighting
                weightedVelX += velocityHistory[i].x * weight;
                weightedVelY += velocityHistory[i].y * weight;
                totalWeight += weight;
            }

            return {
                x: weightedVelX / totalWeight,
                y: weightedVelY / totalWeight,
            };
        };

        /**
         * iOS-like inertia animation with time-based deceleration
         */
        let _pinchZooming = false;
        let initialPinchDistance = 0;
        let initialZoomRatio = 1;
        let pinchCenter: IPoint = { x: 0, y: 0 };
        const cancelInertiaAnimation = () => {
            inertiaFrameSubscription?.unsubscribe();
            inertiaFrameSubscription = null;
            inertiaMotion = null;
            if (scrollInertiaAnimationID !== null) {
                cancelAnimationFrame(scrollInertiaAnimationID);
                scrollInertiaAnimationID = null;
            }
            velocity.x = 0;
            velocity.y = 0;
        };

        this.disposeWithMe(toDisposable(this._context.activated$.subscribe((active) => {
            if (!active) {
                cancelInertiaAnimation();
            }
        })));

        this.disposeWithMe(toDisposable(transformer.changeStart$.subscribe(() => {
            _drawingTransforming = true;
            _touchScrolling = false;
            velocityHistory.length = 0;
            cancelInertiaAnimation();
        })));
        this.disposeWithMe(toDisposable(transformer.changeEnd$.subscribe(() => {
            _drawingTransforming = false;
        })));

        const scrollInertia = async (currentTime: number) => {
            const motion = inertiaMotion;
            if (!motion || !viewportMain) {
                return;
            }

            if (_pinchZooming || this._context.unit.getActiveSheet()?.getSheetId() !== motion.sheetId) {
                cancelInertiaAnimation();
                return;
            }
            const elapsed = Math.min(motion.duration, Math.max(0, currentTime - motion.startTime));
            const { decelerationRate } = getZoomAdjustedParams();
            const dampingFactor = -Math.log(decelerationRate);
            const distanceFactor = (1 - decelerationRate ** elapsed) / dampingFactor * INERTIA_DISTANCE_SCALE;
            const distanceX = motion.velocityX * distanceFactor;
            const distanceY = motion.velocityY * distanceFactor;
            const offsetX = distanceX - motion.distanceX;
            const offsetY = distanceY - motion.distanceY;
            const previousX = viewportMain.viewportScrollX;
            const previousY = viewportMain.viewportScrollY;

            if (offsetX !== 0 || offsetY !== 0) {
                try {
                    await this._commandService.executeCommand(SetScrollRelativeCommand.id, { offsetY, offsetX }, { fromMobileInertia: true });
                } catch (error) {
                    if (inertiaMotion === motion) {
                        cancelInertiaAnimation();
                    }
                    throw error;
                }
                if (inertiaMotion !== motion) {
                    return;
                }
                if (viewportMain.viewportScrollX === previousX && viewportMain.viewportScrollY === previousY &&
                    !viewportMain.isDirty && !viewportMain.isForceDirty) {
                    cancelInertiaAnimation();
                    return;
                }
            }
            motion.distanceX = distanceX;
            motion.distanceY = distanceY;
            if (elapsed < motion.duration) {
                queueInertiaFrame();
            } else {
                cancelInertiaAnimation();
            }
        };
        function queueInertiaFrame() {
            if (engine?.beginFrame$) {
                inertiaFrameSubscription = engine.beginFrame$.pipe(take(1)).subscribe(() => {
                    inertiaFrameSubscription = null;
                    return scrollInertia(performance.now());
                });
            } else {
                scrollInertiaAnimationID = requestAnimationFrame((time) => {
                    scrollInertiaAnimationID = null;
                    return scrollInertia(time);
                });
            }
        }
        // Get the canvas element for native touch events
        const canvasElement = engine?.getCanvasElement();
        if (!canvasElement) return;

        // ============== Pinch-to-Zoom State ==============

        // Store the cell position at pinch center for maintaining focus point
        let pinchCenterCellInfo: {
            row: number;
            column: number;
            rowOffset: number; // offset within the cell
            columnOffset: number;
            cellStartX: number; // cell's start X in viewport coords
            cellStartY: number;
        } | null = null;

        // Store the initial scroll position when pinch starts
        // This is more reliable than cell-based calculation for maintaining position
        let pinchStartScrollPos: { x: number; y: number } | null = null;
        // Store the sheet position at pinch center (in unscaled sheet coordinates)
        let pinchSheetPos: { x: number; y: number } | null = null;

        // Create zoom indicator overlay
        const zoomIndicator = new MobileZoomIndicator(canvasElement);

        /**
         * Convert touch event to offset coordinates relative to canvas
         */
        const getTouchOffset = (touch: Pick<Touch, 'clientX' | 'clientY'>): { offsetX: number; offsetY: number } => {
            const rect = canvasElement.getBoundingClientRect();
            return {
                offsetX: touch.clientX - rect.left,
                offsetY: touch.clientY - rect.top,
            };
        };

        /**
         * Calculate distance between two touch points
         */
        const getTouchDistance = (touch1: Pick<Touch, 'clientX' | 'clientY'>, touch2: Pick<Touch, 'clientX' | 'clientY'>): number => {
            const dx = touch1.clientX - touch2.clientX;
            const dy = touch1.clientY - touch2.clientY;
            return Math.sqrt(dx * dx + dy * dy);
        };

        /**
         * Get center point between two touches (in canvas coordinates)
         */
        const getPinchCenter = (touch1: Pick<Touch, 'clientX' | 'clientY'>, touch2: Pick<Touch, 'clientX' | 'clientY'>): IPoint => {
            const offset1 = getTouchOffset(touch1);
            const offset2 = getTouchOffset(touch2);
            return {
                x: (offset1.offsetX + offset2.offsetX) / 2,
                y: (offset1.offsetY + offset2.offsetY) / 2,
            };
        };

        /**
         * Check if touch is within spreadsheet area (not on headers)
         */
        const isTouchOnSpreadsheet = (offsetX: number, offsetY: number): boolean => {
            const skeleton = this._sheetSkeletonManagerService.getCurrentParam()?.skeleton;
            if (!skeleton) return false;
            const { rowHeaderWidthAndMarginLeft, columnHeaderHeightAndMarginTop } = skeleton;
            return offsetX > rowHeaderWidthAndMarginLeft && offsetY > columnHeaderHeightAndMarginTop;
        };

        /**
         * Convert canvas coordinates to cell information
         */
        const getCellInfoAtPoint = (canvasX: number, canvasY: number, zoomRatio: number): typeof pinchCenterCellInfo => {
            const skeleton = this._sheetSkeletonManagerService.getCurrentParam()?.skeleton;
            if (!skeleton || !viewportMain) return null;

            const { rowHeaderWidthAndMarginLeft, columnHeaderHeightAndMarginTop } = skeleton;

            // Convert canvas coordinates to viewport scroll coordinates
            const viewportScrollX = viewportMain.viewportScrollX || 0;
            const viewportScrollY = viewportMain.viewportScrollY || 0;

            // Calculate the actual position in the sheet (accounting for zoom and scroll)
            const sheetX = (canvasX - rowHeaderWidthAndMarginLeft) / zoomRatio + viewportScrollX;
            const sheetY = (canvasY - columnHeaderHeightAndMarginTop) / zoomRatio + viewportScrollY;

            // Find which cell this corresponds to
            const { row, column, rowOffset, columnOffset } = skeleton.getOffsetRelativeToRowCol(
                Math.max(0, sheetX),
                Math.max(0, sheetY)
            );

            // Get the cell's start position
            const cellInfo = skeleton.getCellWithCoordByIndex(row, column, false);

            return {
                row,
                column,
                rowOffset,
                columnOffset,
                cellStartX: cellInfo.startX,
                cellStartY: cellInfo.startY,
            };
        };

        /**
         * Apply zoom and adjust scroll to keep pinch center in place
         */
        const applyZoomWithFocus = (newZoomRatio: number, oldZoomRatio: number) => {
            if (!viewportMain) return;

            const skeleton = this._sheetSkeletonManagerService.getCurrentParam()?.skeleton;
            if (!skeleton) return;

            const { rowHeaderWidthAndMarginLeft, columnHeaderHeightAndMarginTop } = skeleton;

            // Get current scroll position
            const currentViewportScrollX = viewportMain.viewportScrollX || 0;
            const currentViewportScrollY = viewportMain.viewportScrollY || 0;

            // The position of pinch center in canvas coordinates (relative to content area)
            const pinchCanvasX = pinchCenter.x - rowHeaderWidthAndMarginLeft;
            const pinchCanvasY = pinchCenter.y - columnHeaderHeightAndMarginTop;

            let newViewportScrollX: number;
            let newViewportScrollY: number;

            // Use pinchSheetPos (stored at pinch start) for more stable calculation
            if (pinchSheetPos) {
                // Calculate new scroll position to keep the pinch point stationary
                // The pinchSheetPos is the fixed point in sheet coordinates that should stay under the finger
                // At any zoom: canvasPos = (sheetPos - scrollPos) * zoom
                // Solving for scrollPos: scrollPos = sheetPos - canvasPos / zoom
                newViewportScrollX = pinchSheetPos.x - pinchCanvasX / newZoomRatio;
                newViewportScrollY = pinchSheetPos.y - pinchCanvasY / newZoomRatio;
            } else if (pinchCenterCellInfo) {
                // Fallback to cell-based calculation
                const pinchSheetX = pinchCenterCellInfo.cellStartX + pinchCenterCellInfo.columnOffset;
                const pinchSheetY = pinchCenterCellInfo.cellStartY + pinchCenterCellInfo.rowOffset;
                newViewportScrollX = pinchSheetX - pinchCanvasX / newZoomRatio;
                newViewportScrollY = pinchSheetY - pinchCanvasY / newZoomRatio;
            } else {
                // No reference point available, maintain current position ratio
                const zoomChange = newZoomRatio / oldZoomRatio;
                newViewportScrollX = currentViewportScrollX / zoomChange;
                newViewportScrollY = currentViewportScrollY / zoomChange;
            }

            // Only clamp negative values - don't force to 0 unnecessarily
            // This prevents the "snapping to origin" issue
            if (newViewportScrollX < 0) {
                newViewportScrollX = 0;
            }
            if (newViewportScrollY < 0) {
                newViewportScrollY = 0;
            }

            // Apply zoom first
            const workbook = this._context.unit;
            const worksheet = workbook.getActiveSheet();
            if (!worksheet) return;

            this._commandService.executeCommand(SetZoomRatioCommand.id, {
                zoomRatio: newZoomRatio,
                unitId: workbook.getUnitId(),
                subUnitId: worksheet.getSheetId(),
            });

            // Then apply scroll adjustment
            const { row, column, rowOffset, columnOffset } = skeleton.getOffsetRelativeToRowCol(
                newViewportScrollX,
                newViewportScrollY
            );

            this._commandService.executeCommand(ScrollCommand.id, {
                sheetViewStartRow: row,
                sheetViewStartColumn: column,
                offsetX: columnOffset,
                offsetY: rowOffset,
            });
        };

        // Use onPointerDown$ as trigger to maintain header event compatibility
        // This ensures the event system knows scrolling has started
        spreadsheet.onPointerDown$.subscribeEvent((evt: IPointerEvent | IMouseEvent, state) => {
            cancelInertiaAnimation();
            state.stopPropagation();
        });

        // Helper function to initialize pinch zoom state
        const initializePinchZoom = (touch1: Pick<Touch, 'clientX' | 'clientY'>, touch2: Pick<Touch, 'clientX' | 'clientY'>) => {
            _pinchZooming = true;
            this._contextService.setContextValue(MOBILE_PINCH_ZOOMING, true);
            initialPinchDistance = getTouchDistance(touch1, touch2);
            initialZoomRatio = getCurrentZoomRatio();
            pinchCenter = getPinchCenter(touch1, touch2);

            // Store the cell info at pinch center
            pinchCenterCellInfo = getCellInfoAtPoint(pinchCenter.x, pinchCenter.y, initialZoomRatio);

            // Store initial scroll position and calculate sheet position at pinch center
            if (viewportMain) {
                const skeleton = this._sheetSkeletonManagerService.getCurrentParam()?.skeleton;
                if (skeleton) {
                    const { rowHeaderWidthAndMarginLeft, columnHeaderHeightAndMarginTop } = skeleton;
                    pinchStartScrollPos = {
                        x: viewportMain.viewportScrollX || 0,
                        y: viewportMain.viewportScrollY || 0,
                    };
                    const pinchCanvasX = pinchCenter.x - rowHeaderWidthAndMarginLeft;
                    const pinchCanvasY = pinchCenter.y - columnHeaderHeightAndMarginTop;
                    pinchSheetPos = {
                        x: pinchStartScrollPos.x + pinchCanvasX / initialZoomRatio,
                        y: pinchStartScrollPos.y + pinchCanvasY / initialZoomRatio,
                    };
                }
            }
        };

        // Native touch event handlers for better mobile scrolling experience
        const handleTouchStart = (e: IMobileTouchEvent) => {
            // Handle pinch-to-zoom (two fingers)
            cancelInertiaAnimation();
            if (_drawingTransforming || scene.objectsEvented === false) {
                e.preventDefault();
                return;
            }
            if (e.touches.length === 2) {
                const touch1 = e.touches[0];
                const touch2 = e.touches[1];

                // Check if both touches are on spreadsheet area
                const offset1 = getTouchOffset(touch1);
                const offset2 = getTouchOffset(touch2);
                if (!isTouchOnSpreadsheet(offset1.offsetX, offset1.offsetY) ||
                    !isTouchOnSpreadsheet(offset2.offsetX, offset2.offsetY)) {
                    return;
                }

                // Cancel any single-touch scrolling
                _touchScrolling = false;

                // Initialize pinch state
                initializePinchZoom(touch1, touch2);

                // Show zoom indicator
                zoomIndicator.show(Math.round(initialZoomRatio * 100));

                e.preventDefault();
                return;
            }

            // Single touch - handle scrolling
            if (e.touches.length !== 1) return;

            // If we were pinch zooming and now only one finger, don't start scrolling immediately
            if (_pinchZooming) return;

            // Don't start scrolling if selection is being expanded (dragging fill controls)
            if (this._contextService.getContextValue(MOBILE_EXPANDING_SELECTION)) return;

            const touch = e.touches[0];
            const { offsetX, offsetY } = getTouchOffset(touch);

            // Only start scrolling if touch is on spreadsheet area
            if (!isTouchOnSpreadsheet(offsetX, offsetY)) return;

            // Unselected drawings allow sheet navigation; selected drawings and controls own the gesture.
            const pickedObject = scene.pick(Vector2.FromArray([offsetX, offsetY]), DeviceType.Touch);
            if (pickedObject && pickedObject !== spreadsheet) {
                if (pickedObject instanceof Scene) {
                    return;
                }
                const drawing = pickedObject.ancestorGroup ?? pickedObject;
                const isDrawing = drawing instanceof DrawingGroupObject || SHEET_DRAWING_OBJECT_TYPES.includes(pickedObject.objectType);
                if (!isDrawing || transformer.getSelectedObjectMap().has(drawing.oKey)) {
                    return;
                }
            }

            lastTouchPos.x = offsetX;
            lastTouchPos.y = offsetY;
            lastMoveTime = performance.now();
            swipeStartTime = lastMoveTime;
            swipeTotalDisplacement = { x: 0, y: 0 };
            velocityHistory.length = 0;
            _touchScrolling = true;

            // Prevent default to avoid browser scroll behavior
            e.preventDefault();
        };

        // eslint-disable-next-line max-lines-per-function
        const handleTouchMove = (e: IMobileTouchEvent) => {
            if (_drawingTransforming || scene.objectsEvented === false) {
                _touchScrolling = false;
                velocityHistory.length = 0;
                cancelInertiaAnimation();
                e.preventDefault();
                return;
            }

            // Handle pinch-to-zoom
            if (_pinchZooming && e.touches.length === 2) {
                // Extra protection: ensure inertia is cancelled during zoom
                if (scrollInertiaAnimationID !== null) {
                    cancelInertiaAnimation();
                }

                const touch1 = e.touches[0];
                const touch2 = e.touches[1];

                const currentDistance = getTouchDistance(touch1, touch2);
                const scale = currentDistance / initialPinchDistance;

                // Calculate new zoom ratio with constraints (mobile: 25% - 200%)
                let newZoomRatio = initialZoomRatio * scale;
                const MOBILE_ZOOM_MIN = 0.2;
                const MOBILE_ZOOM_MAX = 2;
                newZoomRatio = Math.max(MOBILE_ZOOM_MIN, Math.min(MOBILE_ZOOM_MAX, newZoomRatio));
                // Round to one decimal place for smoother updates
                newZoomRatio = Math.round(newZoomRatio * 10) / 10;

                const currentZoom = getCurrentZoomRatio();
                if (Math.abs(newZoomRatio - currentZoom) >= 0.05) {
                    // Update pinch center for smooth experience
                    pinchCenter = getPinchCenter(touch1, touch2);

                    // Apply zoom with focus point
                    applyZoomWithFocus(newZoomRatio, currentZoom);

                    // Update zoom indicator
                    zoomIndicator.show(Math.round(newZoomRatio * 100));
                }

                e.preventDefault();
                return;
            }

            // Handle scrolling
            if (!_touchScrolling) return;
            if (e.touches.length !== 1) return;
            if (!viewportMain) return;

            // Don't process scroll if selection is being expanded
            if (this._contextService.getContextValue(MOBILE_EXPANDING_SELECTION)) return;

            const touch = e.touches[0];
            const { offsetX, offsetY } = getTouchOffset(touch);
            const currentTime = performance.now();
            const deltaTime = currentTime - lastMoveTime;

            if (deltaTime <= 0) return;

            const rawDeltaX = -(offsetX - lastTouchPos.x);
            const rawDeltaY = -(offsetY - lastTouchPos.y);

            // Adjust delta by zoom ratio to maintain consistent scroll feel at any zoom level
            // When zoomed in, divide by larger ratio = less scroll (less sensitive)
            // When zoomed out, divide by smaller ratio = more scroll (more responsive)
            const zoomRatio = getCurrentZoomRatio();
            let deltaX = rawDeltaX / zoomRatio;
            let deltaY = rawDeltaY / zoomRatio;
            // Match wheel filtering without locking the gesture: deliberate diagonals and turns remain available.
            if (Math.abs(rawDeltaY) >= Math.abs(rawDeltaX) * TOUCH_CROSS_AXIS_LOCK_RATIO) {
                deltaX = 0;
            } else if (Math.abs(rawDeltaX) >= Math.abs(rawDeltaY) * TOUCH_CROSS_AXIS_LOCK_RATIO) {
                deltaY = 0;
            }

            // Track total displacement for flick detection.
            // Use raw values for gesture detection to maintain consistent flick recognition
            swipeTotalDisplacement.x += Math.abs(rawDeltaX);
            swipeTotalDisplacement.y += Math.abs(rawDeltaY);

            // Calculate instantaneous velocity (pixels per millisecond)
            // Track both directions for velocity history
            const instantVelX = deltaX / deltaTime * 16;
            const instantVelY = deltaY / deltaTime * 16;

            // Add to velocity history
            velocityHistory.push({
                x: instantVelX,
                y: instantVelY,
                time: currentTime,
            });

            // Keep only recent samples
            while (velocityHistory.length > VELOCITY_HISTORY_SIZE) {
                velocityHistory.shift();
            }

            // Apply scroll immediately for responsive feel
            if (deltaX !== 0 || deltaY !== 0) {
                this._commandService.executeCommand(SetScrollRelativeCommand.id, { offsetY: deltaY, offsetX: deltaX });
            }

            lastTouchPos.x = offsetX;
            lastTouchPos.y = offsetY;
            lastMoveTime = currentTime;

            // Prevent default to avoid browser scroll behavior
            e.preventDefault();
        };

        const handleTouchEnd = (e: IMobileTouchEvent) => {
            if (e.touches.length === 0) {
                _drawingTransforming = false;
            }

            // Handle pinch zoom end
            if (_pinchZooming) {
                if (e.touches.length < 2) {
                    _pinchZooming = false;
                    this._contextService.setContextValue(MOBILE_PINCH_ZOOMING, false);
                    pinchCenterCellInfo = null;
                    pinchStartScrollPos = null;
                    pinchSheetPos = null;
                    // Ensure inertia is fully cancelled after zoom
                    cancelInertiaAnimation();
                    velocityHistory.length = 0;
                    // Hide zoom indicator with delay
                    zoomIndicator.hide();
                }
                return;
            }

            // Handle scroll end
            if (!_touchScrolling) return;
            _touchScrolling = false;

            // Calculate final velocity from history
            const avgVelocity = calculateAverageVelocity();

            // Calculate swipe characteristics for dynamic inertia
            const swipeDuration = performance.now() - swipeStartTime;
            const totalDistance = Math.sqrt(
                swipeTotalDisplacement.x * swipeTotalDisplacement.x +
                swipeTotalDisplacement.y * swipeTotalDisplacement.y
            );
            const instantVelocity = Math.sqrt(avgVelocity.x * avgVelocity.x + avgVelocity.y * avgVelocity.y);

            // Get dynamic velocity multiplier based on swipe characteristics
            const dynamicMultiplier = calculateDynamicVelocityMultiplier(swipeDuration, totalDistance, instantVelocity);

            const { maxVelocity, minVelocityThreshold } = getZoomAdjustedParams();

            // Velocity is already zoom-adjusted since it's calculated from zoom-adjusted deltas
            // No additional zoom adjustment needed here

            // Apply dynamic velocity multiplier and cap
            const cappedVelX = Math.max(-maxVelocity, Math.min(maxVelocity, avgVelocity.x * dynamicMultiplier));
            const cappedVelY = Math.max(-maxVelocity, Math.min(maxVelocity, avgVelocity.y * dynamicMultiplier));

            // Use recent weighted motion so release jitter cannot turn a fling onto the other axis.
            const horizontal = Math.abs(avgVelocity.x) > Math.abs(avgVelocity.y);
            velocity.x = horizontal ? cappedVelX : 0;
            velocity.y = horizontal ? 0 : cappedVelY;

            // Only start inertia if velocity is significant
            const speed = Math.sqrt(velocity.x * velocity.x + velocity.y * velocity.y);
            if (speed > minVelocityThreshold * 2) {
                inertiaMotion = {
                    startTime: performance.now(),
                    duration: Math.log(speed / minVelocityThreshold) / -Math.log(BASE_DECELERATION_RATE),
                    sheetId: this._context.unit.getActiveSheet().getSheetId(),
                    velocityX: velocity.x,
                    velocityY: velocity.y,
                    distanceX: 0,
                    distanceY: 0,
                };
                queueInertiaFrame();
            }

            velocityHistory.length = 0;
        };

        const handleTouchCancel = () => {
            _drawingTransforming = false;
            if (_pinchZooming) {
                _pinchZooming = false;
                this._contextService.setContextValue(MOBILE_PINCH_ZOOMING, false);
                pinchCenterCellInfo = null;
                pinchStartScrollPos = null;
                pinchSheetPos = null;
                zoomIndicator.hide();
            }
            if (_touchScrolling) {
                _touchScrolling = false;
                velocityHistory.length = 0;
            }
            // Always cancel inertia on touch cancel
            cancelInertiaAnimation();
        };

        // Add native touch event listeners with passive: false to allow preventDefault
        // DOM drawings forward pointer events to the canvas, but their native touches stay on the DOM.
        const forwardedTouches = new Map<number, PointerEvent>();
        let domOwnsForwardedPan = false;
        const finishForwardedPointer = (event: PointerEvent) => {
            if (event.pointerType !== 'touch' || !forwardedTouches.delete(event.pointerId)) {
                return;
            }
            if (event.type === 'pointercancel') {
                handleTouchCancel();
            } else {
                handleTouchEnd({ touches: Array.from(forwardedTouches.values()), preventDefault: () => event.preventDefault() });
            }
        };
        const handleForwardedPointer = (event: PointerEvent) => {
            if (event.pointerType !== 'touch') {
                return;
            }
            if (event.type === 'pointerdown' && event.isPrimary && forwardedTouches.size) {
                // A new primary touch cannot coexist with pointers left over from an interrupted gesture.
                forwardedTouches.clear();
                handleTouchCancel();
            }
            if (event.type === 'pointerup' || event.type === 'pointercancel') {
                finishForwardedPointer(event);
                return;
            }
            if (event.isTrusted) {
                return;
            }
            if (event.type === 'pointerdown') {
                forwardedTouches.set(event.pointerId, event);
                if (forwardedTouches.size === 1) {
                    const { offsetX, offsetY } = getTouchOffset(event);
                    const picked = scene.pick(Vector2.FromArray([offsetX, offsetY]), DeviceType.Touch);
                    // DOM blocks route their native touch pan to the host; chart DOM only forwards pointers.
                    domOwnsForwardedPan = !(picked instanceof Scene) && picked?.objectType === ObjectType.DRAWING_DOM;
                }
                if (!domOwnsForwardedPan || forwardedTouches.size > 1) {
                    handleTouchStart({ touches: Array.from(forwardedTouches.values()), preventDefault: () => event.preventDefault() });
                }
            } else if (forwardedTouches.has(event.pointerId)) {
                if (event.type === 'pointermove') {
                    forwardedTouches.set(event.pointerId, event);
                    if (!domOwnsForwardedPan || forwardedTouches.size > 1) {
                        handleTouchMove({ touches: Array.from(forwardedTouches.values()), preventDefault: () => event.preventDefault() });
                    }
                }
            }
        };
        // Pointer capture can end a DOM gesture on the canvas or outside its original layer.
        document.addEventListener('pointerup', finishForwardedPointer, true);
        document.addEventListener('pointercancel', finishForwardedPointer, true);
        const forwardedPointerEvents = ['pointerdown', 'pointermove', 'pointerup', 'pointercancel'] as const;
        forwardedPointerEvents.forEach((type) => canvasElement.addEventListener(type, handleForwardedPointer));

        canvasElement.addEventListener('touchstart', handleTouchStart, { passive: false });
        canvasElement.addEventListener('touchmove', handleTouchMove, { passive: false });
        canvasElement.addEventListener('touchend', handleTouchEnd, { passive: false });
        canvasElement.addEventListener('touchcancel', handleTouchCancel, { passive: false });

        // Clean up touch event listeners on dispose
        this.disposeWithMe(toDisposable(() => {
            canvasElement.removeEventListener('touchstart', handleTouchStart);
            canvasElement.removeEventListener('touchmove', handleTouchMove);
            canvasElement.removeEventListener('touchend', handleTouchEnd);
            canvasElement.removeEventListener('touchcancel', handleTouchCancel);
            forwardedPointerEvents.forEach((type) => canvasElement.removeEventListener(type, handleForwardedPointer));
            document.removeEventListener('pointerup', finishForwardedPointer, true);
            document.removeEventListener('pointercancel', finishForwardedPointer, true);
            handleTouchCancel();
            forwardedTouches.clear();
            zoomIndicator.dispose();
        }));

        // Note: We intentionally do NOT add handleScrollEnd listeners for onPointerLeave$/onPointerOut$
        // When using native touch events, the touch can move outside the spreadsheet area (into headers)
        // but the scroll should continue. The scroll will only end on touchend/touchcancel events.
        // This fixes the issue where scrolling would stop when finger moves over row/column headers.
    }

    private _updateSceneSize(param: ISheetSkeletonManagerParam) {
        if (param == null) {
            return;
        }

        const { unitId } = this._context;
        const { skeleton } = param;
        const scene = this._renderManagerService.getRenderUnitById(unitId)?.scene;

        if (skeleton == null || scene == null) {
            return;
        }

        const { rowTotalHeight, columnTotalWidth, rowHeaderWidthAndMarginLeft, columnHeaderHeightAndMarginTop } =
            skeleton;

        // Note: Do NOT call scene.setScaleValueOnly here.
        // Zoom is handled by SheetsZoomRenderController._updateViewZoom which calls scene.scale().
        // Calling setScaleValueOnly here can cause scroll position issues when zooming back to 100%.
        scene?.transformByState({
            width: rowHeaderWidthAndMarginLeft + columnTotalWidth,
            height: columnHeaderHeightAndMarginTop + rowTotalHeight,
        });
    }

    private _getSheetObject() {
        return getSheetObject(this._context.unit, this._context);
    }

    private _scrollToSelection(targetIsActualRowAndColumn = true) {
        const selection = this._selectionManagerService.getCurrentLastSelection();
        if (selection == null) {
            return;
        }

        const { startRow, startColumn, actualRow, actualColumn } = selection.primary;
        const selectionStartRow = targetIsActualRowAndColumn ? actualRow : startRow;
        const selectionStartColumn = targetIsActualRowAndColumn ? actualColumn : startColumn;

        this._scrollToCell(selectionStartRow, selectionStartColumn);
    }

    private _getViewportBounding() {
        const scene = this._getSheetObject()?.scene;
        if (scene == null) {
            return;
        }

        const viewport = scene.getViewport(SHEET_VIEWPORT_KEY.VIEW_MAIN);
        if (viewport == null) {
            return;
        }

        const skeleton = this._sheetSkeletonManagerService.getCurrentParam()?.skeleton;
        if (skeleton == null) {
            return;
        }

        return skeleton.getRangeByViewport(viewport.calcViewportInfo());
    }

    // eslint-disable-next-line max-lines-per-function, complexity
    private _scrollToCell(row: number, column: number): boolean {
        const { rowHeightAccumulation, columnWidthAccumulation } = this._sheetSkeletonManagerService.getCurrentParam()?.skeleton ?? {};

        if (rowHeightAccumulation == null || columnWidthAccumulation == null) return false;

        const scene = this._getSheetObject()?.scene;
        if (scene == null) return false;

        const viewport = scene.getViewport(SHEET_VIEWPORT_KEY.VIEW_MAIN);
        if (viewport == null) return false;

        const skeleton = this._sheetSkeletonManagerService.getCurrentParam()?.skeleton;
        if (skeleton == null) return false;

        const worksheet = this._context.unit.getActiveSheet();
        if (!worksheet) return false;

        const {
            startColumn: freezeStartColumn,
            startRow: freezeStartRow,
            ySplit: freezeYSplit,
            xSplit: freezeXSplit,
        } = worksheet.getFreeze();

        const bounds = this._getViewportBounding();
        if (bounds == null) return false;

        const {
            startRow: viewportStartRow,
            startColumn: viewportStartColumn,
            endRow: viewportEndRow,
            endColumn: viewportEndColumn,
        } = bounds;

        let startSheetViewRow: number | undefined;
        let startSheetViewColumn: number | undefined;

        // vertical overflow only happens when the selection's row is in not the freeze area
        if (row >= freezeStartRow && column >= freezeStartColumn - freezeXSplit) {
            // top overflow
            if (row <= viewportStartRow) {
                startSheetViewRow = row;
            }

            // bottom overflow
            if (row >= viewportEndRow) {
                const minRowAccumulation = rowHeightAccumulation[row] - viewport.height!;
                for (let r = viewportStartRow; r <= row; r++) {
                    if (rowHeightAccumulation[r] >= minRowAccumulation) {
                        startSheetViewRow = r + 1;
                        break;
                    }
                }
            }
        }
        // horizontal overflow only happens when the selection's column is in not the freeze area
        if (column >= freezeStartColumn && row >= freezeStartRow - freezeYSplit) {
            // left overflow
            if (column <= viewportStartColumn) {
                startSheetViewColumn = column;
            }

            // right overflow
            if (column >= viewportEndColumn) {
                const minColumnAccumulation = columnWidthAccumulation[column] - viewport.width!;
                for (let c = viewportStartColumn; c <= column; c++) {
                    if (columnWidthAccumulation[c] >= minColumnAccumulation) {
                        startSheetViewColumn = c + 1;
                        break;
                    }
                }
            }
        }

        if (startSheetViewRow === undefined && startSheetViewColumn === undefined) return false;

        const { offsetX, offsetY } = this._scrollManagerService.getCurrentScrollState() || {};
        return this._commandService.syncExecuteCommand(ScrollCommand.id, {
            sheetViewStartRow: startSheetViewRow,
            sheetViewStartColumn: startSheetViewColumn,
            offsetX: startSheetViewColumn === undefined ? offsetX : 0,
            offsetY: startSheetViewRow === undefined ? offsetY : 0,
        });
    }
}