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.

fix(sheets-ui): stabilize fill direction after scrolling (#8095)

白熱03f898475ae0
diff --git a/packages/sheets-ui/src/services/selection/__tests__/selection-shape-extension.spec.ts b/packages/sheets-ui/src/services/selection/__tests__/selection-shape-extension.spec.ts
new file mode 100644
index 0000000000..7ac1610ef5
--- /dev/null
+++ b/packages/sheets-ui/src/services/selection/__tests__/selection-shape-extension.spec.ts
@@ -0,0 +1,316 @@
+/**
+ * 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, IRangeWithCoord, IWorkbookData, Workbook } from '@univerjs/core';
+import type { IPointerEvent } from '@univerjs/engine-render';
+import { ICommandService, LocaleType, Univer, UniverInstanceType } from '@univerjs/core';
+import {
+ CanvasColorService,
+ ICanvasColorService,
+ IRenderManagerService,
+ RenderManagerService,
+ ScrollBar,
+ SHEET_VIEWPORT_KEY,
+ Spreadsheet,
+ Viewport,
+} from '@univerjs/engine-render';
+import {
+ SetSelectionsOperation,
+ SheetInterceptorService,
+ SheetSkeletonService,
+ SheetsSelectionsService,
+} from '@univerjs/sheets';
+import {
+ IPlatformService,
+ IShortcutService,
+ IUIRuntimeScopeService,
+ PlatformService,
+ ShortcutService,
+ UIRuntimeScopeService,
+} from '@univerjs/ui';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { SHEET_VIEW_KEY } from '../../../common/keys';
+import { SheetSkeletonManagerService } from '../../sheet-skeleton-manager.service';
+import { ISheetSelectionRenderService } from '../base-selection-render.service';
+import { RANGE_FILL_PERMISSION_CHECK } from '../const';
+import { SheetSelectionRenderService } from '../selection-render.service';
+
+interface IFixtureOptions {
+ scrollX?: number;
+ scrollY?: number;
+ scale?: number;
+ viewportKey?: SHEET_VIEWPORT_KEY;
+ range?: IRange;
+ mergeData?: IRange[];
+ freeze?: IFreeze;
+}
+
+let frameCallback: FrameRequestCallback | undefined;
+
+const cleanups: Array<() => void> = [];
+
+function createFixture(options: IFixtureOptions = {}) {
+ const { scrollX = 0, scrollY = 0, scale = 1, viewportKey = SHEET_VIEWPORT_KEY.VIEW_MAIN } = options;
+ const univer = new Univer({ locale: LocaleType.EN_US });
+ cleanups.push(() => univer.dispose());
+ const injector = univer.__getInjector();
+ injector.add([ICanvasColorService, { useClass: CanvasColorService }]);
+ injector.add([IRenderManagerService, { useClass: RenderManagerService }]);
+ injector.add([SheetSkeletonService]);
+ injector.add([SheetInterceptorService]);
+ injector.add([SheetsSelectionsService]);
+ injector.add([IPlatformService, { useClass: PlatformService }]);
+ injector.add([IUIRuntimeScopeService, { useClass: UIRuntimeScopeService }]);
+ injector.add([IShortcutService, { useClass: ShortcutService }]);
+ injector.get(SheetSkeletonService);
+ injector.get(SheetInterceptorService);
+ injector.get(ICommandService).registerCommand(SetSelectionsOperation);
+ const renderManager = injector.get(IRenderManagerService);
+ renderManager.registerRenderModule(UniverInstanceType.UNIVER_SHEET, [SheetSkeletonManagerService]);
+ const workbook = univer.createUnit<IWorkbookData, Workbook>(UniverInstanceType.UNIVER_SHEET, {
+ id: 'fill-drag',
+ sheetOrder: ['sheet'],
+ sheets: {
+ sheet: {
+ id: 'sheet',
+ rowCount: 300,
+ columnCount: 100,
+ defaultColumnWidth: 100,
+ defaultRowHeight: 20,
+ mergeData: options.mergeData ?? [],
+ freeze: options.freeze,
+ },
+ },
+ });
+ const render = renderManager.createRender(workbook.getUnitId());
+ const { engine, scene } = render;
+ engine.resizeBySize(1200, 800);
+ scene.transformByState({ width: 10000, height: 6000, scaleX: scale, scaleY: scale });
+ const viewport = new Viewport(viewportKey, scene, { left: 0, top: 0, width: 1200, height: 800 });
+ const scrollbar = new ScrollBar(viewport, { mainScene: scene });
+ const spreadsheet = new Spreadsheet(SHEET_VIEW_KEY.MAIN);
+ render.mainComponent = spreadsheet;
+ render.components.set(SHEET_VIEW_KEY.MAIN, spreadsheet);
+ scene.addObject(spreadsheet);
+ const skeletonManager = render.with(SheetSkeletonManagerService);
+ skeletonManager.setCurrent({ sheetId: 'sheet' });
+ const skeleton = skeletonManager.getCurrentSkeleton()!;
+ renderManager.registerRenderModule(UniverInstanceType.UNIVER_SHEET, [SheetSelectionRenderService]);
+ const selectionService = render.with(SheetSelectionRenderService);
+ render.getInjector!().add([ISheetSelectionRenderService, { useValue: selectionService }]);
+ const permission = selectionService.interceptor.intercept(RANGE_FILL_PERMISSION_CHECK, { handler: () => true });
+ viewport.scrollToViewportPos({ viewportScrollX: scrollX, viewportScrollY: scrollY });
+ const range = options.range ?? {
+ startRow: scrollY / 20 + 3,
+ endRow: scrollY / 20 + 7,
+ startColumn: scrollX / 100 + 2,
+ endColumn: scrollX / 100 + 2,
+ };
+ const control = selectionService.newSelectionControl(scene, skeleton, { range, primary: null });
+ const previews: IRangeWithCoord[] = [];
+ const fills: IRangeWithCoord[] = [];
+ const previewSub = control.selectionFilling$.subscribe((value) => {
+ if (value) {
+ previews.push(value);
+ }
+ });
+ const fillSub = control.selectionFilled$.subscribe((value) => {
+ if (value) {
+ fills.push(value);
+ }
+ });
+ const endCell = skeleton.getNoMergeCellWithCoordByIndex(range.endRow, range.endColumn);
+ const startX = (endCell.endX - scrollX) * scale;
+ const startY = (endCell.endY - scrollY) * scale;
+ const event = (x: number, y: number) => ({ offsetX: x, offsetY: y }) as IPointerEvent;
+ cleanups.push(() => {
+ previewSub.unsubscribe();
+ fillSub.unsubscribe();
+ permission();
+ scrollbar.dispose();
+ });
+ return {
+ viewport,
+ scene,
+ range,
+ previews,
+ fills,
+ control,
+ startX,
+ startY,
+ down: () => control.fillControl.onPointerDown$.emitEvent(event(startX, startY)),
+ move: (dx: number, dy: number) => scene.onPointerMove$.emitEvent(event(startX + dx, startY + dy)),
+ up: () => scene.onPointerUp$.emitEvent(event(startX, startY)),
+ };
+}
+
+beforeEach(() => {
+ vi.spyOn(HTMLCanvasElement.prototype, 'getContext').mockReturnValue({
+ setTransform: () => {},
+ clearRect: () => {},
+ } as unknown as CanvasRenderingContext2D);
+ frameCallback = undefined;
+ vi.spyOn(window, 'requestAnimationFrame').mockImplementation((callback) => {
+ frameCallback = callback;
+ return 1;
+ });
+ vi.spyOn(window, 'cancelAnimationFrame').mockImplementation(() => {});
+});
+
+afterEach(() => {
+ cleanups.splice(0).reverse().forEach((cleanup) => cleanup());
+ vi.restoreAllMocks();
+});
+
+describe('SelectionShapeExtension autofill', () => {
+ it.each([0.5, 1, 2])('keeps horizontal fill stable around the bottom edge after scrolling at %sx zoom', (scale) => {
+ const fixture = createFixture({ scrollY: 1320, scale });
+ fixture.down();
+ for (const dy of [-2, 2, -2, 2]) {
+ fixture.move(200 * scale, dy * scale);
+ expect(fixture.previews.at(-1)).toMatchObject({ ...fixture.range, endColumn: 5 });
+ }
+ fixture.up();
+ expect(fixture.fills).toEqual([fixture.previews.at(-1)]);
+ });
+
+ it.each([
+ { scrollX: 0, scrollY: 0 },
+ { scrollX: 2000, scrollY: 0 },
+ { scrollX: 2000, scrollY: 1320 },
+ ])('preserves all four fill directions with initial scroll $scrollX, $scrollY', (scroll) => {
+ const fixture = createFixture(scroll);
+ const { range } = fixture;
+ fixture.down();
+ const gestures = [
+ { dx: 200, dy: 2, expected: { ...range, endColumn: range.endColumn + 3 } },
+ { dx: -250, dy: 2, expected: { ...range, startColumn: range.startColumn - 2 } },
+ { dx: 2, dy: 80, expected: { ...range, endRow: range.endRow + 5 } },
+ { dx: 2, dy: -130, expected: { ...range, startRow: range.startRow - 2 } },
+ ];
+ for (const { dx, dy, expected } of gestures) {
+ fixture.move(dx, dy);
+ expect(fixture.previews.at(-1)).toMatchObject(expected);
+ }
+ fixture.up();
+ expect(fixture.fills).toEqual([fixture.previews.at(-1)]);
+ });
+
+ it.each([
+ { dx: 120, dy: 50, endRow: 7, endColumn: 4 },
+ { dx: 80, dy: 50, endRow: 10, endColumn: 2 },
+ ])('preserves diagonal direction choice for ($dx, $dy)', ({ dx, dy, endRow, endColumn }) => {
+ const fixture = createFixture();
+ fixture.down();
+ fixture.move(dx, dy);
+ fixture.up();
+ expect(fixture.fills.at(-1)).toMatchObject({ ...fixture.range, endRow, endColumn });
+ });
+
+ it.each([
+ { dx: -150, dy: -2, endRow: 7, endColumn: 3 },
+ { dx: -2, dy: -50, endRow: 5, endColumn: 4 },
+ ])('preserves shrinking a selection by dragging inside ($dx, $dy)', ({ dx, dy, endRow, endColumn }) => {
+ const fixture = createFixture({ range: { startRow: 3, endRow: 7, startColumn: 2, endColumn: 4 } });
+ fixture.down();
+ fixture.move(dx, dy);
+ fixture.up();
+ expect(fixture.fills.at(-1)).toMatchObject({ ...fixture.range, endRow, endColumn });
+ });
+
+ it.each([0.5, 1, 2])('counts horizontal scrolling during a drag at %sx zoom', (scale) => {
+ const fixture = createFixture({ scrollY: 1320, scale });
+ fixture.down();
+ fixture.viewport.scrollToViewportPos({ viewportScrollX: 600 });
+ fixture.move(2 * scale, 100 * scale);
+ fixture.up();
+ expect(fixture.fills.at(-1)).toMatchObject({ ...fixture.range, endColumn: 9 });
+ });
+
+ it.each([0.5, 1, 2])('counts vertical scrolling during a drag at %sx zoom', (scale) => {
+ const fixture = createFixture({ scrollX: 2000, scale });
+ fixture.down();
+ fixture.viewport.scrollToViewportPos({ viewportScrollY: 200 });
+ fixture.move(300 * scale, 2 * scale);
+ fixture.up();
+ expect(fixture.fills.at(-1)).toMatchObject({ ...fixture.range, endRow: 18 });
+ });
+
+ it('extends the preview as edge auto-scroll advances without further pointer movement', () => {
+ const fixture = createFixture({ scrollY: 1320 });
+ fixture.down();
+ fixture.move(840, 2);
+ const firstEndColumn = fixture.previews.at(-1)!.endColumn;
+ for (let i = 0; i < 5; i++) {
+ frameCallback!(i * 16);
+ }
+ expect(fixture.viewport.viewportScrollX).toBeGreaterThan(0);
+ expect(fixture.previews.at(-1)).toMatchObject({
+ startRow: fixture.range.startRow,
+ endRow: fixture.range.endRow,
+ });
+ expect(fixture.previews.at(-1)!.endColumn).toBeGreaterThan(firstEndColumn);
+ fixture.up();
+ expect(fixture.fills).toEqual([fixture.previews.at(-1)]);
+ });
+
+ it.each([
+ { viewportKey: SHEET_VIEWPORT_KEY.VIEW_MAIN_TOP, scrollX: 2000, scrollY: 0, dx: 2, dy: 80 },
+ { viewportKey: SHEET_VIEWPORT_KEY.VIEW_MAIN_LEFT, scrollX: 0, scrollY: 1320, dx: 200, dy: 2 },
+ ])('fills within frozen viewport $viewportKey using its own scroll', (options) => {
+ const fixture = createFixture(options);
+ fixture.down();
+ fixture.move(options.dx, options.dy);
+ fixture.up();
+ const expected = options.dx === 2
+ ? { ...fixture.range, endRow: fixture.range.endRow + 5 }
+ : { ...fixture.range, endColumn: fixture.range.endColumn + 3 };
+ expect(fixture.fills.at(-1)).toMatchObject(expected);
+ });
+
+ it('keeps merged fill targets aligned to the source block after scrolling', () => {
+ const range = { startRow: 69, endRow: 70, startColumn: 2, endColumn: 3 };
+ const fixture = createFixture({ scrollY: 1320, range, mergeData: [range] });
+ fixture.down();
+ fixture.move(250, 2);
+ fixture.up();
+ expect(fixture.fills.at(-1)).toMatchObject({ ...range, endColumn: 7 });
+ });
+ it('keeps horizontal fill stable when crossing from frozen columns into the scrolled main viewport', () => {
+ const fixture = createFixture({
+ scrollY: 1320,
+ viewportKey: SHEET_VIEWPORT_KEY.VIEW_MAIN_LEFT,
+ range: { startRow: 69, endRow: 73, startColumn: 1, endColumn: 1 },
+ freeze: { startRow: -1, startColumn: 3, xSplit: 3, ySplit: 0 },
+ });
+ fixture.viewport.setViewportSize({ width: 346 });
+ const main = new Viewport(SHEET_VIEWPORT_KEY.VIEW_MAIN, fixture.scene, {
+ left: 346,
+ top: 0,
+ width: 854,
+ height: 800,
+ });
+ const scrollbar = new ScrollBar(main, { mainScene: fixture.scene });
+ main.scrollToViewportPos({ viewportScrollX: 500, viewportScrollY: 1320 });
+ cleanups.push(() => scrollbar.dispose());
+ fixture.down();
+ fixture.move(250, 2);
+ fixture.move(350, 2);
+ fixture.up();
+ expect(fixture.fills.at(-1)).toMatchObject({ ...fixture.range, endColumn: 5 });
+ expect(main.viewportScrollX).toBe(0);
+ });
+});
diff --git a/packages/sheets-ui/src/services/selection/selection-shape-extension.ts b/packages/sheets-ui/src/services/selection/selection-shape-extension.ts
index e0ebdfd706..02938e2e2e 100644
--- a/packages/sheets-ui/src/services/selection/selection-shape-extension.ts
+++ b/packages/sheets-ui/src/services/selection/selection-shape-extension.ts
@@ -18,10 +18,19 @@ import type { IFreeze, Injector, IRange, IRangeWithCoord, Nullable, ThemeService
import type { IMouseEvent, IPointerEvent, Scene, SpreadsheetSkeleton, Viewport } from '@univerjs/engine-render';
import type { ISelectionWithStyle } from '@univerjs/sheets';
import type { Subscription } from 'rxjs';
-import type { SelectionControl } from './selection-control';
import { ColorKit, IUniverInstanceService, LookUp, Quantity, UniverInstanceType } from '@univerjs/core';
-import { CURSOR_TYPE, IRenderManagerService, Rect, ScrollTimer, ScrollTimerType, SHEET_VIEWPORT_KEY, Vector2, withCurrentTypeOfRenderer } from '@univerjs/engine-render';
+import {
+ CURSOR_TYPE,
+ IRenderManagerService,
+ Rect,
+ ScrollTimer,
+ ScrollTimerType,
+ SHEET_VIEWPORT_KEY,
+ Vector2,
+ withCurrentTypeOfRenderer,
+} from '@univerjs/engine-render';
import { attachSelectionWithCoord, SELECTION_CONTROL_BORDER_BUFFER_WIDTH } from '@univerjs/sheets';
+import type { SelectionControl } from './selection-control';
import { SheetSkeletonManagerService } from '../sheet-skeleton-manager.service';
import { ISheetSelectionRenderService } from './base-selection-render.service';
import { genNormalSelectionStyle, RANGE_FILL_PERMISSION_CHECK, RANGE_MOVE_PERMISSION_CHECK } from './const';
@@ -614,15 +623,10 @@ export class SelectionShapeExtension {
fillControl.onPointerDown$.subscribeEvent(this._autoFillForPointerdown.bind(this));
}
- // eslint-disable-next-line complexity
private _autoFillMoving(moveOffsetX: number, moveOffsetY: number) {
const scene = this._scene;
- // const activeViewport = scene.getActiveViewportByCoord(Vector2.FromArray([moveOffsetX, moveOffsetY]));
- // const scrollXY = activeViewport ? scene.getScrollXY(activeViewport) : { x: 0, y: 0 };
const scrollXY = scene.getViewportScrollXY(this._activeViewport);
-
const { scaleX, scaleY } = scene.getAncestorScale();
-
const moveActualSelection = this._skeleton.getCellIndexByOffset(
moveOffsetX,
moveOffsetY,
@@ -630,27 +634,16 @@ export class SelectionShapeExtension {
scaleY,
scrollXY
);
-
const { row, column } = moveActualSelection;
-
const moveRelativeCoords = scene.getCoordRelativeToViewport(Vector2.FromArray([moveOffsetX, moveOffsetY]));
-
const maxRow = this._skeleton.getRowCount() - 1;
-
const maxColumn = this._skeleton.getColumnCount() - 1;
-
let startRow = this._relativeSelectionPositionRow;
-
let startColumn = this._relativeSelectionPositionColumn;
-
let endRow = this._relativeSelectionPositionRow + this._relativeSelectionRowLength;
-
let endColumn = this._relativeSelectionPositionColumn + this._relativeSelectionColumnLength;
-
let isLighten = false;
-
let isRowDropping = true;
-
if ((column < startColumn || column > endColumn) && row >= startRow && row <= endRow) {
const rulerValue = this._fillRuler(
column,
@@ -659,25 +652,18 @@ export class SelectionShapeExtension {
this._relativeSelectionColumnLength,
maxColumn
);
-
startColumn = rulerValue.startRowOrColumn;
-
endColumn = rulerValue.endRowOrColumn;
-
isLighten = rulerValue.isLighten;
-
isRowDropping = false;
} else if ((row < startRow || row > endRow) && column >= startColumn && column <= endColumn) {
const rulerValue = this._fillRuler(row, startRow, endRow, this._relativeSelectionRowLength, maxRow);
-
startRow = rulerValue.startRowOrColumn;
-
endRow = rulerValue.endRowOrColumn;
-
isLighten = rulerValue.isLighten;
} else if (
- Math.abs(this._startOffsetX - moveRelativeCoords.x - scrollXY.x) / 2 >
- Math.abs(this._startOffsetY - moveRelativeCoords.y - scrollXY.y)
+ Math.abs(this._startOffsetX - moveRelativeCoords.x - scrollXY.x * scaleX) / 2 >
+ Math.abs(this._startOffsetY - moveRelativeCoords.y - scrollXY.y * scaleY)
) {
const rulerValue = this._fillRuler(
column,
@@ -686,24 +672,21 @@ export class SelectionShapeExtension {
this._relativeSelectionColumnLength,
maxColumn
);
-
startColumn = rulerValue.startRowOrColumn;
-
endColumn = rulerValue.endRowOrColumn;
-
isLighten = rulerValue.isLighten;
-
isRowDropping = false;
} else {
const rulerValue = this._fillRuler(row, startRow, endRow, this._relativeSelectionRowLength, maxRow);
-
startRow = rulerValue.startRowOrColumn;
-
endRow = rulerValue.endRowOrColumn;
-
isLighten = rulerValue.isLighten;
}
+ this._updateAutoFillPreview({ startRow, endRow, startColumn, endColumn }, isLighten, isRowDropping);
+ }
+ private _updateAutoFillPreview(range: IRange, isLighten: boolean, isRowDropping: boolean) {
+ const { startRow, endRow, startColumn, endColumn } = range;
const startCell = this._skeleton.getNoMergeCellWithCoordByIndex(startRow, startColumn);
const endCell = this._skeleton.getNoMergeCellWithCoordByIndex(endRow, endColumn);
@@ -758,37 +741,28 @@ export class SelectionShapeExtension {
this._control.selectionFilling$.next(this._targetSelection);
}
- // eslint-disable-next-line max-lines-per-function
private _autoFillForPointerdown(evt: IMouseEvent | IPointerEvent) {
const { offsetX: evtOffsetX, offsetY: evtOffsetY } = evt;
-
const scene = this._scene;
-
const relativeCoords = scene.getCoordRelativeToViewport(Vector2.FromArray([evtOffsetX, evtOffsetY]));
-
const { x: newEvtOffsetX, y: newEvtOffsetY } = relativeCoords;
-
- this._startOffsetX = newEvtOffsetX;
-
- this._startOffsetY = newEvtOffsetY;
-
+ this._activeViewport = scene.getActiveViewportByCoord(Vector2.FromArray([evtOffsetX, evtOffsetY]))!;
+ const scrollXY = scene.getViewportScrollXY(this._activeViewport);
+ const { scaleX, scaleY } = scene.getAncestorScale();
+ // Use the same scaled sheet coordinates for both ends of the drag, including auto-scroll.
+ this._startOffsetX = newEvtOffsetX + scrollXY.x * scaleX;
+ this._startOffsetY = newEvtOffsetY + scrollXY.y * scaleY;
const {
startRow: originStartRow,
startColumn: originStartColumn,
endRow: originEndRow,
endColumn: originEndColumn,
} = this._control.model;
-
this._isInMergeState = this._hasMergeInRange(originStartRow, originStartColumn, originEndRow, originEndColumn);
-
this._relativeSelectionPositionRow = originStartRow;
-
this._relativeSelectionPositionColumn = originStartColumn;
-
this._relativeSelectionRowLength = originEndRow - originStartRow;
-
this._relativeSelectionColumnLength = originEndColumn - originStartColumn;
-
const style = this._control.currentStyle;
let stroke = style?.stroke;
let strokeWidth = style?.strokeWidth;
@@ -796,19 +770,13 @@ export class SelectionShapeExtension {
if (stroke == null) {
stroke = defaultStyle.stroke;
}
-
if (strokeWidth == null) {
strokeWidth = defaultStyle.strokeWidth;
}
-
const scale = this._getScale();
-
strokeWidth /= scale;
-
const SELECTION_CONTROL_BORDER_BUFFER_WIDTH_SCALE = SELECTION_CONTROL_BORDER_BUFFER_WIDTH / scale;
-
const darkenColor = new ColorKit(stroke).darken(2).toRgbString();
-
if (this.isHelperSelection) {
this._helperSelection = new Rect(HELPER_SELECTION_TEMP_NAME, {
stroke: darkenColor,
@@ -816,92 +784,22 @@ export class SelectionShapeExtension {
});
scene.addObject(this._helperSelection);
}
-
- this._activeViewport = scene.getActiveViewportByCoord(Vector2.FromArray([evtOffsetX, evtOffsetY]))!;
-
const viewportMain = scene.getViewport(SHEET_VIEWPORT_KEY.VIEW_MAIN);
-
const scrollTimer = ScrollTimer.create(
scene,
this._activeViewport.viewportKey === SHEET_VIEWPORT_KEY.VIEW_MAIN ? ScrollTimerType.ALL : ScrollTimerType.NONE
);
-
scrollTimer.startScroll(newEvtOffsetX, newEvtOffsetY, viewportMain);
-
this._scrollTimer = scrollTimer;
-
scene.disableObjectsEvent();
-
this._controlHandler((o) => {
this._fillControlColors.push(o.fill as string);
});
-
// Controls the border of the expanding selection area
+ const originRange = this._control.model.getRange();
this._scenePointerMoveSub = scene.onPointerMove$.subscribeEvent((moveEvt: IPointerEvent | IMouseEvent) => {
- const { offsetX: moveOffsetX, offsetY: moveOffsetY } = moveEvt;
- const currentViewport = scene.getActiveViewportByCoord(Vector2.FromArray([moveOffsetX, moveOffsetY]));
-
- const permissionCheck = this._injector.get(ISheetSelectionRenderService, LookUp.SELF).interceptor.fetchThroughInterceptors(RANGE_FILL_PERMISSION_CHECK)(false, { x: evt.offsetX, y: evt.offsetY, skeleton: this._skeleton, scene: this._scene });
-
- if (!permissionCheck) {
- return;
- }
-
- const { x: newMoveOffsetX, y: newMoveOffsetY } = scene.getCoordRelativeToViewport(
- Vector2.FromArray([moveOffsetX, moveOffsetY])
- );
-
- this._autoFillMoving(newMoveOffsetX, newMoveOffsetY);
-
- scene.setCursor(CURSOR_TYPE.CROSSHAIR);
-
- const newSelection = this._targetSelection;
-
- if (viewportMain && currentViewport && this._activeViewport?.viewportKey !== currentViewport?.viewportKey) {
- let movingRange: IRangeWithCoord;
- if (newSelection.startRow !== originStartRow) {
- scrollTimer.scrollTimerType = ScrollTimerType.Y;
- movingRange = {
- ...newSelection,
- endRow: newSelection.startRow,
- };
- } else if (newSelection.endRow !== originEndRow) {
- scrollTimer.scrollTimerType = ScrollTimerType.Y;
- movingRange = {
- ...newSelection,
- startRow: newSelection.endRow,
- };
- } else if (newSelection.startColumn !== originStartColumn) {
- scrollTimer.scrollTimerType = ScrollTimerType.X;
- movingRange = {
- ...newSelection,
- endColumn: newSelection.startColumn,
- };
- } else {
- scrollTimer.scrollTimerType = ScrollTimerType.X;
- movingRange = {
- ...newSelection,
- startColumn: newSelection.endColumn,
- };
- }
-
- if (this._isSelectionInViewport(movingRange, currentViewport)) {
- if (this._viewportMainScrollBarNeedResetPosition(scrollTimer.scrollTimerType, this._activeViewport.viewportKey, currentViewport.viewportKey)) {
- viewportMain.scrollToBarPos({
- x: scrollTimer.scrollTimerType === ScrollTimerType.X ? 0 : undefined,
- y: scrollTimer.scrollTimerType === ScrollTimerType.Y ? 0 : undefined,
- });
- }
-
- this._activeViewport = currentViewport;
- }
- }
-
- scrollTimer.scrolling(newMoveOffsetX, newMoveOffsetY, () => {
- this._autoFillMoving(newMoveOffsetX, newMoveOffsetY);
- });
+ this._autoFillForPointermove(moveEvt, evt, originRange, viewportMain);
});
-
this._scenePointerUpSub = scene.onPointerUp$.subscribeEvent(() => {
this._helperSelection?.dispose();
const scene = this._scene;
@@ -920,6 +818,79 @@ export class SelectionShapeExtension {
});
}
+ private _autoFillForPointermove(
+ moveEvt: IMouseEvent | IPointerEvent,
+ startEvt: IMouseEvent | IPointerEvent,
+ originRange: IRange,
+ viewportMain: Nullable<Viewport>
+ ) {
+ const scene = this._scene;
+ const scrollTimer = this._scrollTimer;
+ const { startRow: originStartRow, endRow: originEndRow, startColumn: originStartColumn } = originRange;
+ const { offsetX: moveOffsetX, offsetY: moveOffsetY } = moveEvt;
+ const currentViewport = scene.getActiveViewportByCoord(Vector2.FromArray([moveOffsetX, moveOffsetY]));
+
+ const permissionCheck = this._injector.get(ISheetSelectionRenderService, LookUp.SELF).interceptor.fetchThroughInterceptors(RANGE_FILL_PERMISSION_CHECK)(false, { x: startEvt.offsetX, y: startEvt.offsetY, skeleton: this._skeleton, scene: this._scene });
+
+ if (!permissionCheck) {
+ return;
+ }
+
+ const { x: newMoveOffsetX, y: newMoveOffsetY } = scene.getCoordRelativeToViewport(
+ Vector2.FromArray([moveOffsetX, moveOffsetY])
+ );
+
+ this._autoFillMoving(newMoveOffsetX, newMoveOffsetY);
+
+ scene.setCursor(CURSOR_TYPE.CROSSHAIR);
+
+ const newSelection = this._targetSelection;
+
+ if (viewportMain && currentViewport && this._activeViewport?.viewportKey !== currentViewport?.viewportKey) {
+ let movingRange: IRangeWithCoord;
+ if (newSelection.startRow !== originStartRow) {
+ scrollTimer.scrollTimerType = ScrollTimerType.Y;
+ movingRange = {
+ ...newSelection,
+ endRow: newSelection.startRow,
+ };
+ } else if (newSelection.endRow !== originEndRow) {
+ scrollTimer.scrollTimerType = ScrollTimerType.Y;
+ movingRange = {
+ ...newSelection,
+ startRow: newSelection.endRow,
+ };
+ } else if (newSelection.startColumn !== originStartColumn) {
+ scrollTimer.scrollTimerType = ScrollTimerType.X;
+ movingRange = {
+ ...newSelection,
+ endColumn: newSelection.startColumn,
+ };
+ } else {
+ scrollTimer.scrollTimerType = ScrollTimerType.X;
+ movingRange = {
+ ...newSelection,
+ startColumn: newSelection.endColumn,
+ };
+ }
+
+ if (this._isSelectionInViewport(movingRange, currentViewport)) {
+ if (this._viewportMainScrollBarNeedResetPosition(scrollTimer.scrollTimerType, this._activeViewport.viewportKey, currentViewport.viewportKey)) {
+ viewportMain.scrollToBarPos({
+ x: scrollTimer.scrollTimerType === ScrollTimerType.X ? 0 : undefined,
+ y: scrollTimer.scrollTimerType === ScrollTimerType.Y ? 0 : undefined,
+ });
+ }
+
+ this._activeViewport = currentViewport;
+ }
+ }
+
+ scrollTimer.scrolling(newMoveOffsetX, newMoveOffsetY, () => {
+ this._autoFillMoving(newMoveOffsetX, newMoveOffsetY);
+ });
+ }
+
private _viewportMainScrollBarNeedResetPosition(scrollTimerType: ScrollTimerType, activeViewportKey: string, currentViewportKey: string): boolean {
// When the auto fill operation will pass through freeze position, the viewport main scroll bar needs to be reset to the left or top position.
// The viewport main scroll bar needs to be reset to the left position only when the auto fill operation direction is from left to right.