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): allow mobile checkbox taps through selection handles (#8092)

白熱ac45cbc7ba22
diff --git a/packages/sheets-ui/src/controllers/__tests__/cell-custom-render.controller.spec.ts b/packages/sheets-ui/src/controllers/__tests__/cell-custom-render.controller.spec.ts
index 27e936a71a..9a748d09a9 100644
--- a/packages/sheets-ui/src/controllers/__tests__/cell-custom-render.controller.spec.ts
+++ b/packages/sheets-ui/src/controllers/__tests__/cell-custom-render.controller.spec.ts
@@ -14,28 +14,19 @@
* limitations under the License.
*/
+import type { Workbook } from '@univerjs/core';
+import type { IPointerEvent, IRenderContext } from '@univerjs/engine-render';
+import { EventSubject, Injector, IPermissionService } from '@univerjs/core';
+import { IRenderManagerService } from '@univerjs/engine-render';
import { UnitAction } from '@univerjs/protocol';
import { Subject } from 'rxjs';
-import { describe, expect, it, vi } from 'vitest';
+import { afterEach, describe, expect, it, vi } from 'vitest';
+import { SheetSkeletonManagerService } from '../../services/sheet-skeleton-manager.service';
import { CellCustomRenderController } from '../cell-custom-render.controller';
-function createEventSubject() {
- const subscribers = new Set<(evt: any) => void>();
-
- return {
- subscribeEvent: vi.fn((handler: (evt: any) => void) => {
- subscribers.add(handler);
- const unsubscribe = vi.fn(() => subscribers.delete(handler));
-
- return { dispose: unsubscribe, unsubscribe };
- }),
- emit: (evt: any) => subscribers.forEach((handler) => handler(evt)),
- };
-}
-
function createController(options?: { editable?: boolean; selectionEditable?: boolean }) {
- const pointerDown$ = createEventSubject();
- const pointerMove$ = createEventSubject();
+ const pointerDown$ = new EventSubject<Pick<IPointerEvent, 'offsetX' | 'offsetY'>>();
+ const pointerMove$ = new EventSubject<Pick<IPointerEvent, 'offsetX' | 'offsetY'>>();
const renderA = {
zIndex: 1,
isHit: vi.fn(() => true),
@@ -64,7 +55,7 @@ function createController(options?: { editable?: boolean; selectionEditable?: bo
getCellIndexByOffset: vi.fn(() => ({ row: 1, column: 2 })),
getCellWithCoordByIndex: vi.fn(() => ({ startX: 10, startY: 20 })),
};
- const currentSkeleton$ = new Subject<any>();
+ const currentSkeleton$ = new Subject<{ skeleton: typeof skeleton }>();
const spreadsheet = {
onPointerDown$: pointerDown$,
onPointerMove$: pointerMove$,
@@ -73,36 +64,46 @@ function createController(options?: { editable?: boolean; selectionEditable?: bo
getActiveViewportByCoord: vi.fn(() => ({ viewportScrollX: 5, viewportScrollY: 6 })),
getAncestorScale: vi.fn(() => ({ scaleX: 2, scaleY: 2 })),
};
- const controller = new CellCustomRenderController(
- {
- unitId: 'unit-1',
- unit: { getActiveSheet: vi.fn(() => worksheet) },
- } as any,
- {
- currentSkeleton$,
- getCurrentParam: vi.fn(() => ({ skeleton })),
- } as any,
- {
- getRenderUnitById: vi.fn(() => ({ mainComponent: spreadsheet, scene })),
- } as any,
- {
- composePermission: vi.fn(() => [{ value: options?.editable ?? true }]),
- } as any
- );
+ const context = {
+ unitId: 'unit-1',
+ unit: { getActiveSheet: vi.fn(() => worksheet) },
+ } as unknown as IRenderContext<Workbook>;
+ const injector = new Injector([
+ [SheetSkeletonManagerService, {
+ useValue: {
+ currentSkeleton$,
+ getCurrentParam: vi.fn(() => ({ skeleton })),
+ },
+ }],
+ [IRenderManagerService, {
+ useValue: {
+ getRenderUnitById: vi.fn(() => ({ mainComponent: spreadsheet, scene })),
+ },
+ }],
+ [IPermissionService, {
+ useValue: {
+ composePermission: vi.fn(() => [{ value: options?.editable ?? true }]),
+ },
+ }],
+ ]);
- return { controller, pointerDown$, pointerMove$, renderA, renderB, currentSkeleton$, skeleton, worksheet };
+ return { injector, context, pointerDown$, pointerMove$, renderA, renderB };
}
+afterEach(() => vi.useRealTimers());
+
describe('CellCustomRenderController', () => {
it('dispatches pointer events to hit custom renderers when sheet and cell are editable', async () => {
- const { controller, pointerDown$, pointerMove$, renderA, renderB } = createController();
+ vi.useFakeTimers();
+ const { injector, context, pointerDown$, pointerMove$, renderA, renderB } = createController();
+ const controller = injector.createInstance(CellCustomRenderController, context);
- pointerDown$.emit({ offsetX: 20, offsetY: 30 });
- pointerMove$.emit({ offsetX: 20, offsetY: 30 });
- await new Promise((resolve) => setTimeout(resolve, 35));
+ pointerDown$.emitEvent({ offsetX: 20, offsetY: 30 });
+ pointerMove$.emitEvent({ offsetX: 20, offsetY: 30 });
+ await vi.advanceTimersByTimeAsync(35);
renderA.isHit.mockReturnValue(false);
- pointerMove$.emit({ offsetX: 200, offsetY: 300 });
- await new Promise((resolve) => setTimeout(resolve, 35));
+ pointerMove$.emitEvent({ offsetX: 200, offsetY: 300 });
+ await vi.advanceTimersByTimeAsync(35);
expect(renderA.onPointerDown).toHaveBeenCalled();
expect(renderA.onPointerEnter).toHaveBeenCalled();
@@ -110,17 +111,18 @@ describe('CellCustomRenderController', () => {
expect(renderB.onPointerEnter).not.toHaveBeenCalled();
controller.dispose();
+ injector.dispose();
});
- it('does not dispatch pointer down when workbook or protected cell is not editable', () => {
- const nonEditable = createController({ editable: false });
- nonEditable.pointerDown$.emit({ offsetX: 20, offsetY: 30 });
- expect(nonEditable.renderA.onPointerDown).not.toHaveBeenCalled();
- nonEditable.controller.dispose();
-
- const protectedCell = createController({ selectionEditable: false });
- protectedCell.pointerDown$.emit({ offsetX: 20, offsetY: 30 });
- expect(protectedCell.renderA.onPointerDown).not.toHaveBeenCalled();
- protectedCell.controller.dispose();
+ it.each([
+ { editable: false, selectionEditable: true },
+ { editable: true, selectionEditable: false },
+ ])('does not dispatch pointer down when editing is denied: %j', (permissions) => {
+ const { injector, context, pointerDown$, renderA } = createController(permissions);
+ const controller = injector.createInstance(CellCustomRenderController, context);
+ pointerDown$.emitEvent({ offsetX: 20, offsetY: 30 });
+ expect(renderA.onPointerDown).not.toHaveBeenCalled();
+ controller.dispose();
+ injector.dispose();
});
});
diff --git a/packages/sheets-ui/src/controllers/cell-custom-render.controller.ts b/packages/sheets-ui/src/controllers/cell-custom-render.controller.ts
index 32d48c5460..199913b37b 100644
--- a/packages/sheets-ui/src/controllers/cell-custom-render.controller.ts
+++ b/packages/sheets-ui/src/controllers/cell-custom-render.controller.ts
@@ -27,7 +27,9 @@ import type {
IRenderContext,
IRenderModule,
RenderManagerService,
+ Scene,
Spreadsheet,
+ SpreadsheetSkeleton,
} from '@univerjs/engine-render';
import type { ICellPermission, ISheetSkeletonManagerParam } from '@univerjs/sheets';
import {
@@ -60,159 +62,12 @@ export class CellCustomRenderController extends Disposable implements IRenderMod
this._initEventBinding();
}
- // eslint-disable-next-line max-lines-per-function
private _initEventBinding() {
const disposableCollection = new DisposableCollection();
-
- const workbook = this._context.unit;
- // eslint-disable-next-line max-lines-per-function
const handleSkeletonChange = (skeletonParam: Nullable<ISheetSkeletonManagerParam>) => {
disposableCollection.dispose();
- if (!skeletonParam) {
- return;
- }
-
- const unitId = this._context.unitId;
- const { skeleton } = skeletonParam;
- const currentRender = this._renderManagerService.getRenderUnitById(unitId);
- if (currentRender && currentRender.mainComponent) {
- const spreadsheet = currentRender.mainComponent as Spreadsheet;
- // eslint-disable-next-line max-lines-per-function
- const getActiveRender = (evt: IPointerEvent | IMouseEvent) => {
- const { offsetX, offsetY } = evt;
- const scene = currentRender.scene;
- const worksheet = workbook.getActiveSheet();
-
- if (!worksheet) {
- return;
- }
-
- const activeViewport = scene.getActiveViewportByCoord(
- Vector2.FromArray([offsetX, offsetY])
- );
-
- if (!activeViewport) {
- return;
- }
-
- const { scaleX, scaleY } = scene.getAncestorScale();
-
- const scrollXY = {
- x: activeViewport.viewportScrollX,
- y: activeViewport.viewportScrollY,
- };
-
- const cellPos = skeleton.getCellIndexByOffset(offsetX, offsetY, scaleX, scaleY, scrollXY);
-
- // const mergeCell = skeleton.mergeData.find((range) => {
- // const { startColumn, startRow, endColumn, endRow } = range;
- // return cellPos.row >= startRow && cellPos.column >= startColumn && cellPos.row <= endRow && cellPos.column <= endColumn;
- // });
- const mergeCell = skeleton.worksheet.getMergedCell(cellPos.row, cellPos.column);
-
- const cellIndex = {
- actualRow: mergeCell ? mergeCell.startRow : cellPos.row,
- actualCol: mergeCell ? mergeCell.startColumn : cellPos.column,
- mergeCell,
- row: cellPos.row,
- col: cellPos.column,
- };
-
- if (!cellIndex || !skeleton) {
- return;
- }
-
- const cellData = worksheet.getCell(cellIndex.actualRow, cellIndex.actualCol);
- if (!cellData) {
- return;
- }
-
- const renders = cellData.customRender;
-
- if (!renders?.length) {
- return;
- }
- const row = cellIndex.actualRow;
- const col = cellIndex.actualCol;
- const sortedRenders = renders.sort(sortRules);
- const subUnitId = worksheet.getSheetId();
-
- const info: ICellRenderContext = {
- data: cellData,
- style: worksheet.getComposedCellStyleByCellData(row, col, cellData),
- primaryWithCoord: skeleton.getCellWithCoordByIndex(cellIndex.actualRow, cellIndex.actualCol),
- unitId,
- subUnitId,
- row,
- col,
- workbook,
- worksheet,
- };
-
- const position = {
- x: scrollXY.x + (offsetX / scaleX),
- y: scrollXY.y + (offsetY / scaleY),
- };
-
- const activeRender = sortedRenders.find((render) => render.isHit?.(position, info));
- if (!activeRender) {
- return;
- }
- return [activeRender, info] as const;
- };
-
- const disposable = spreadsheet.onPointerDown$.subscribeEvent((evt) => {
- const activeRenderInfo = getActiveRender(evt);
- if (activeRenderInfo) {
- const [activeRender, cellContext] = activeRenderInfo;
- const { row, col, worksheet, unitId, subUnitId } = cellContext;
- const sheetEditable = this._permissionService.composePermission(
- [new WorkbookEditablePermission(unitId).id, new WorksheetEditPermission(unitId, subUnitId).id]
- )?.every((permission) => permission.value);
-
- if (!sheetEditable) {
- return false;
- }
-
- const permission = (worksheet.getCell(row, col) as (ICellDataForSheetInterceptor & { selectionProtection: ICellPermission[] }))?.selectionProtection?.[0];
- if (permission?.[UnitAction.Edit] === false) {
- return false;
- }
-
- activeRender.onPointerDown?.(cellContext, evt);
- }
- });
-
- const moveDisposable = fromEventSubject(spreadsheet.onPointerMove$).pipe(throttleTime(30)).subscribe((evt) => {
- const activeRenderInfo = getActiveRender(evt);
- if (activeRenderInfo) {
- const [activeRender, cellContext] = activeRenderInfo;
- if (this._enterActiveRender) {
- if (this._enterActiveRender.render !== activeRender) {
- this._enterActiveRender.render.onPointerLeave?.(this._enterActiveRender.cellContext, evt);
- this._enterActiveRender = {
- render: activeRender,
- cellContext,
- };
- activeRender.onPointerEnter?.(cellContext, evt);
- }
- } else {
- this._enterActiveRender = {
- render: activeRender,
- cellContext,
- };
- activeRender.onPointerEnter?.(cellContext, evt);
- }
- } else {
- if (this._enterActiveRender) {
- this._enterActiveRender.render.onPointerLeave?.(this._enterActiveRender.cellContext, evt);
- this._enterActiveRender = null;
- }
- }
- });
-
- disposable && disposableCollection.add(disposable);
- moveDisposable && disposableCollection.add(moveDisposable);
+ if (skeletonParam) {
+ this._bindEvents(skeletonParam.skeleton, disposableCollection);
}
};
@@ -220,4 +75,103 @@ export class CellCustomRenderController extends Disposable implements IRenderMod
handleSkeletonChange(this._sheetSkeletonManagerService.getCurrentParam());
this.disposeWithMe(disposableCollection);
}
+
+ private _getActiveRender(evt: IPointerEvent | IMouseEvent, skeleton: SpreadsheetSkeleton, scene: Scene) {
+ const { offsetX, offsetY } = evt;
+ const workbook = this._context.unit;
+ const worksheet = workbook.getActiveSheet();
+ if (!worksheet) {
+ return;
+ }
+
+ const activeViewport = scene.getActiveViewportByCoord(Vector2.FromArray([offsetX, offsetY]));
+ if (!activeViewport) {
+ return;
+ }
+
+ const { scaleX, scaleY } = scene.getAncestorScale();
+ const scrollXY = { x: activeViewport.viewportScrollX, y: activeViewport.viewportScrollY };
+ const cellPos = skeleton.getCellIndexByOffset(offsetX, offsetY, scaleX, scaleY, scrollXY);
+ const mergeCell = skeleton.worksheet.getMergedCell(cellPos.row, cellPos.column);
+ const row = mergeCell ? mergeCell.startRow : cellPos.row;
+ const col = mergeCell ? mergeCell.startColumn : cellPos.column;
+ const cellData = worksheet.getCell(row, col);
+ if (!cellData?.customRender?.length) {
+ return;
+ }
+
+ const info: ICellRenderContext = {
+ data: cellData,
+ style: worksheet.getComposedCellStyleByCellData(row, col, cellData),
+ primaryWithCoord: skeleton.getCellWithCoordByIndex(row, col),
+ unitId: this._context.unitId,
+ subUnitId: worksheet.getSheetId(),
+ row,
+ col,
+ workbook,
+ worksheet,
+ };
+ const position = {
+ x: scrollXY.x + (offsetX / scaleX),
+ y: scrollXY.y + (offsetY / scaleY),
+ };
+ const activeRender = cellData.customRender.sort(sortRules).find((render) => render.isHit?.(position, info));
+ if (activeRender) {
+ return [activeRender, info] as const;
+ }
+ }
+
+ private _bindEvents(skeleton: SpreadsheetSkeleton, disposableCollection: DisposableCollection) {
+ const currentRender = this._renderManagerService.getRenderUnitById(this._context.unitId);
+ if (!currentRender?.mainComponent) {
+ return;
+ }
+
+ const spreadsheet = currentRender.mainComponent as Spreadsheet;
+ const disposable = spreadsheet.onPointerDown$.subscribeEvent((evt) => {
+ const activeRenderInfo = this._getActiveRender(evt, skeleton, currentRender.scene);
+ if (!activeRenderInfo) {
+ return;
+ }
+
+ const [activeRender, cellContext] = activeRenderInfo;
+ const { row, col, worksheet, unitId, subUnitId } = cellContext;
+ const sheetEditable = this._permissionService.composePermission(
+ [new WorkbookEditablePermission(unitId).id, new WorksheetEditPermission(unitId, subUnitId).id]
+ )?.every((permission) => permission.value);
+ if (!sheetEditable) {
+ return false;
+ }
+
+ const permission = (worksheet.getCell(row, col) as (ICellDataForSheetInterceptor & { selectionProtection: ICellPermission[] }))?.selectionProtection?.[0];
+ if (permission?.[UnitAction.Edit] === false) {
+ return false;
+ }
+
+ activeRender.onPointerDown?.(cellContext, evt);
+ });
+ const moveDisposable = fromEventSubject(spreadsheet.onPointerMove$).pipe(throttleTime(30)).subscribe((evt) => {
+ this._handlePointerMove(evt, skeleton, currentRender.scene);
+ });
+
+ disposable && disposableCollection.add(disposable);
+ disposableCollection.add(moveDisposable);
+ }
+
+ private _handlePointerMove(evt: IPointerEvent | IMouseEvent, skeleton: SpreadsheetSkeleton, scene: Scene) {
+ const activeRenderInfo = this._getActiveRender(evt, skeleton, scene);
+ if (activeRenderInfo) {
+ const [activeRender, cellContext] = activeRenderInfo;
+ if (this._enterActiveRender?.render === activeRender) {
+ return;
+ }
+
+ this._enterActiveRender?.render.onPointerLeave?.(this._enterActiveRender.cellContext, evt);
+ this._enterActiveRender = { render: activeRender, cellContext };
+ activeRender.onPointerEnter?.(cellContext, evt);
+ } else if (this._enterActiveRender) {
+ this._enterActiveRender.render.onPointerLeave?.(this._enterActiveRender.cellContext, evt);
+ this._enterActiveRender = null;
+ }
+ }
}
diff --git a/packages/sheets-ui/src/services/selection/__tests__/mobile-selection-shape.spec.ts b/packages/sheets-ui/src/services/selection/__tests__/mobile-selection-shape.spec.ts
new file mode 100644
index 0000000000..38dd95ff8d
--- /dev/null
+++ b/packages/sheets-ui/src/services/selection/__tests__/mobile-selection-shape.spec.ts
@@ -0,0 +1,119 @@
+/**
+ * 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 { ICellCustomRender, IWorkbookData, Workbook } from '@univerjs/core';
+import type { Engine } from '@univerjs/engine-render';
+import { EventSubject, InterceptorEffectEnum, RANGE_TYPE, ThemeService, Univer, UniverInstanceType } from '@univerjs/core';
+import { Scene, SpreadsheetSkeleton, Vector2 } from '@univerjs/engine-render';
+import { attachSelectionWithCoord, INTERCEPTOR_POINT, SheetInterceptorService } from '@univerjs/sheets';
+import { afterEach, describe, expect, it } from 'vitest';
+import { MobileSelectionControl } from '../mobile-selection-shape';
+
+const disposals: Array<() => void> = [];
+
+function createControl(alignment: 'left' | 'right', merged: boolean) {
+ const univer = new Univer();
+ const injector = univer.__getInjector();
+ injector.add([SheetInterceptorService]);
+ const interceptorService = injector.get(SheetInterceptorService);
+ const workbook = univer.createUnit<IWorkbookData, Workbook>(UniverInstanceType.UNIVER_SHEET, {
+ id: 'checkbox',
+ sheetOrder: ['sheet'],
+ sheets: {
+ sheet: {
+ id: 'sheet',
+ name: 'Sheet',
+ rowCount: 20,
+ columnCount: 20,
+ defaultRowHeight: 24,
+ defaultColumnWidth: 88,
+ mergeData: merged ? [{ startRow: 2, endRow: 2, startColumn: 1, endColumn: 2 }] : [],
+ },
+ },
+ });
+ let interactive = true;
+ const widget: ICellCustomRender = {
+ drawWith() {},
+ onPointerDown() {},
+ isHit(position, info) {
+ const bounds = info.primaryWithCoord.isMergedMainCell ? info.primaryWithCoord.mergeInfo : info.primaryWithCoord;
+ const left = alignment === 'left' ? bounds.startX + 6 : bounds.endX - 22;
+ return interactive && position.x >= left && position.x <= left + 16 &&
+ position.y >= bounds.startY + 4 && position.y <= bounds.startY + 20;
+ },
+ };
+ interceptorService.intercept(INTERCEPTOR_POINT.CELL_CONTENT, {
+ effect: InterceptorEffectEnum.Style,
+ handler: (cell, pos, next) => next(pos.row === 2 && pos.col === 1 ? { ...cell, customRender: [widget] } : cell),
+ });
+ const worksheet = workbook.getActiveSheet()!;
+ const skeleton = injector.createInstance(SpreadsheetSkeleton, worksheet, workbook.getStyles());
+ skeleton.calculate();
+ const scene = new Scene('mobile-selection', {
+ onTransformChange$: new EventSubject(),
+ getParent: () => null,
+ } as unknown as Engine, { width: 800, height: 600 });
+ const control = new MobileSelectionControl(scene, 1, injector.get(ThemeService), {
+ rowHeaderWidth: skeleton.rowHeaderWidth,
+ columnHeaderHeight: skeleton.columnHeaderHeight,
+ rangeType: RANGE_TYPE.NORMAL,
+ });
+ const selection = attachSelectionWithCoord({
+ range: { startRow: 2, endRow: 2, startColumn: 1, endColumn: merged ? 2 : 1, rangeType: RANGE_TYPE.NORMAL },
+ primary: worksheet.getCellInfoInMergeData(2, 1),
+ style: null,
+ }, skeleton);
+ control.updateRangeBySelectionWithCoord(selection, skeleton);
+ disposals.push(() => {
+ control.dispose();
+ scene.dispose();
+ skeleton.dispose();
+ univer.dispose();
+ });
+ return {
+ control,
+ selection,
+ removeWidget: () => {
+ interactive = false;
+ },
+ };
+}
+
+afterEach(() => disposals.splice(0).forEach((dispose) => dispose()));
+
+describe('MobileSelectionControl widget hit testing', () => {
+ it.each([
+ { alignment: 'left' as const, merged: false },
+ { alignment: 'right' as const, merged: false },
+ { alignment: 'left' as const, merged: true },
+ { alignment: 'right' as const, merged: true },
+ ])('lets a $alignment-aligned widget receive taps while preserving the selection handle (merged=$merged)', ({ alignment, merged }) => {
+ const { control, selection, removeWidget } = createControl(alignment, merged);
+ const { startX, startY, endX, endY } = selection.rangeWithCoord;
+ const left = alignment === 'left';
+ const handle = left ? control.expandControlTopLeft! : control.expandControlBottomRight!;
+ const widgetCenter = new Vector2(left ? startX + 14 : endX - 14, (startY + endY) / 2);
+ const handleCenter = new Vector2(left ? startX : endX, left ? startY : endY);
+ const padding = new Vector2(handleCenter.x + (left ? -15 : 15), handleCenter.y);
+
+ expect(handle.isHit(widgetCenter)).toBe(false);
+ expect(handle.isHit(handleCenter)).toBe(true);
+ expect(handle.isHit(padding)).toBe(true);
+
+ removeWidget();
+ expect(handle.isHit(widgetCenter)).toBe(true);
+ });
+});
diff --git a/packages/sheets-ui/src/services/selection/mobile-selection-shape.ts b/packages/sheets-ui/src/services/selection/mobile-selection-shape.ts
index 1cf737630f..df5104900c 100644
--- a/packages/sheets-ui/src/services/selection/mobile-selection-shape.ts
+++ b/packages/sheets-ui/src/services/selection/mobile-selection-shape.ts
@@ -14,16 +14,36 @@
* limitations under the License.
*/
-import type { ThemeService } from '@univerjs/core';
-import type { BaseObject, IRectProps, Scene } from '@univerjs/engine-render';
-import type { ISelectionStyle } from '@univerjs/sheets';
+import type { ICellRenderContext, ThemeService } from '@univerjs/core';
+import type { BaseObject, IRectProps, Scene, SpreadsheetSkeleton, Vector2 } from '@univerjs/engine-render';
+import type { ISelectionStyle, ISelectionWithCoord } from '@univerjs/sheets';
import { RANGE_TYPE } from '@univerjs/core';
import { Rect, SHEET_VIEWPORT_KEY } from '@univerjs/engine-render';
-
import { SHEET_COMPONENT_SELECTION_LAYER_INDEX } from '../../common/keys';
import { SELECTION_MANAGER_KEY, SelectionControl } from './selection-control';
+class MobileSelectionHandle extends Rect {
+ constructor(key: string, props: IRectProps, private readonly _isCellWidgetHit: (coord: Vector2) => boolean) {
+ super(key, props);
+ }
+
+ override isHit(coord: Vector2): boolean {
+ if (!super.isHit(coord)) {
+ return false;
+ }
+
+ const local = this.getInverseCoord(coord);
+ const onVisibleHandle = Math.abs(local.x - this.width / 2) <= (this.visualWidth ?? this.width) / 2 &&
+ Math.abs(local.y - this.height / 2) <= (this.visualHeight ?? this.height) / 2;
+
+ // Keep the handle draggable while letting cell widgets receive taps through its invisible padding.
+ return onVisibleHandle || !this._isCellWidgetHit(coord);
+ }
+}
+
export class MobileSelectionControl extends SelectionControl {
+ private _skeleton: SpreadsheetSkeleton | undefined;
+
/**
* topLeft controlPointer, it is not visible, just transparent, for handling event.
*/
@@ -62,7 +82,7 @@ export class MobileSelectionControl extends SelectionControl {
const controlStroke = defaultStyle.autofillStroke!;
const zIndex = this.zIndex;
// @transformControlPoint takes care of left & top
- this._expandControlTopLeft = new Rect(SELECTION_MANAGER_KEY.expandTopLeft + zIndex, {
+ this._expandControlTopLeft = new MobileSelectionHandle(SELECTION_MANAGER_KEY.expandTopLeft + zIndex, {
zIndex: zIndex + 2,
width: expandCornerSize,
height: expandCornerSize,
@@ -70,9 +90,9 @@ export class MobileSelectionControl extends SelectionControl {
visualWidth: expandCornerInnerSize,
visualHeight: expandCornerInnerSize,
strokeWidth: controlStrokeWidth,
- });
+ }, (coord) => this._isCellWidgetHit(coord));
- this._expandControlBottomRight = new Rect(SELECTION_MANAGER_KEY.expandBottomRight + zIndex, {
+ this._expandControlBottomRight = new MobileSelectionHandle(SELECTION_MANAGER_KEY.expandBottomRight + zIndex, {
zIndex: zIndex + 2,
width: expandCornerSize,
height: expandCornerSize,
@@ -80,7 +100,7 @@ export class MobileSelectionControl extends SelectionControl {
visualHeight: expandCornerInnerSize,
visualWidth: expandCornerInnerSize,
strokeWidth: controlStrokeWidth,
- });
+ }, (coord) => this._isCellWidgetHit(coord));
const controlProps: IRectProps = {
fill: stroke,
@@ -136,6 +156,42 @@ export class MobileSelectionControl extends SelectionControl {
this._rangeType = value;
}
+ override updateRangeBySelectionWithCoord(selection: ISelectionWithCoord, skeleton?: SpreadsheetSkeleton, animate = false): void {
+ if (skeleton) {
+ this._skeleton = skeleton;
+ }
+ super.updateRangeBySelectionWithCoord(selection, skeleton, animate);
+ }
+
+ private _isCellWidgetHit(coord: Vector2): boolean {
+ const skeleton = this._skeleton;
+ if (!skeleton) {
+ return false;
+ }
+
+ const { worksheet } = skeleton;
+ const cell = skeleton.getCellWithCoordByOffset(coord.x, coord.y, 1, 1, { x: 0, y: 0 });
+ const row = cell.isMerged ? cell.mergeInfo.startRow : cell.actualRow;
+ const col = cell.isMerged ? cell.mergeInfo.startColumn : cell.actualColumn;
+ const data = worksheet.getCell(row, col);
+ if (!data?.customRender?.length) {
+ return false;
+ }
+
+ const info: ICellRenderContext = {
+ data,
+ style: worksheet.getComposedCellStyleByCellData(row, col, data),
+ primaryWithCoord: skeleton.getCellWithCoordByIndex(row, col),
+ unitId: worksheet.getUnitId(),
+ subUnitId: worksheet.getSheetId(),
+ row,
+ col,
+ worksheet,
+ };
+
+ return data.customRender.some((render) => render.onPointerDown && render.isHit?.(coord, info));
+ }
+
override dispose(): void {
this._expandControlBottomRight?.dispose();
this._expandControlTopLeft?.dispose();
@@ -149,14 +205,12 @@ export class MobileSelectionControl extends SelectionControl {
// startX startY shares same coordinate with viewport.(include row & colheader)
const defaultStyle = this.currentStyle;
- if (style == null) {
- style = defaultStyle;
- }
+ const selectionStyle = style ?? defaultStyle;
const {
widgets = defaultStyle.widgets!,
- } = style;
- this.currentStyle = style;
+ } = selectionStyle;
+ this.currentStyle = selectionStyle;
// this condition is derived from selection-shape, I do not understand.
if (!super._hasWidgets(widgets)) {