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.

perf(sheet): optimize incremental scroll rendering (#7207)

Univer1a6131305533
diff --git a/packages/engine-render/src/__tests__/engine-scene-viewport.spec.ts b/packages/engine-render/src/__tests__/engine-scene-viewport.spec.ts
index e314bff347..10dd5b75c1 100644
--- a/packages/engine-render/src/__tests__/engine-scene-viewport.spec.ts
+++ b/packages/engine-render/src/__tests__/engine-scene-viewport.spec.ts
@@ -865,4 +865,29 @@ describe('engine scene viewport extra', () => {
scene.dispose();
engine.dispose();
});
+
+ it('expands cache diff strips across both axes to avoid exposing blank cache gaps', () => {
+ const { engine, scene, viewport } = createFixture();
+ viewport.bufferEdgeX = 10;
+ viewport.bufferEdgeY = 20;
+
+ const verticalDiff = (viewport as any)._calcDiffCacheBound(
+ { left: 0, top: 0, right: 100, bottom: 100 },
+ { left: 0, top: 50, right: 100, bottom: 150 }
+ );
+ expect(verticalDiff).toEqual([
+ { left: -10, top: 80, right: 110, bottom: 170 },
+ ]);
+
+ const horizontalDiff = (viewport as any)._calcDiffCacheBound(
+ { left: 0, top: 0, right: 100, bottom: 100 },
+ { left: 50, top: 0, right: 150, bottom: 100 }
+ );
+ expect(horizontalDiff).toEqual([
+ { left: 90, top: -20, right: 160, bottom: 120 },
+ ]);
+
+ scene.dispose();
+ engine.dispose();
+ });
});
diff --git a/packages/engine-render/src/components/extension.ts b/packages/engine-render/src/components/extension.ts
index 9e591618b6..87a72db732 100644
--- a/packages/engine-render/src/components/extension.ts
+++ b/packages/engine-render/src/components/extension.ts
@@ -34,6 +34,8 @@ export interface IDrawInfo {
viewRanges: IRange[];
viewportKey: string;
checkOutOfViewBound?: boolean;
+ fontRenderRanges?: IRange[];
+ hasMergeData?: boolean;
viewBound?: IBoundRectNoAngle;
}
export class ComponentExtension<T, U, V> {
diff --git a/packages/engine-render/src/components/sheets/__tests__/spreadsheet.integration.spec.ts b/packages/engine-render/src/components/sheets/__tests__/spreadsheet.integration.spec.ts
index 4ec5bbeebf..a802181bda 100644
--- a/packages/engine-render/src/components/sheets/__tests__/spreadsheet.integration.spec.ts
+++ b/packages/engine-render/src/components/sheets/__tests__/spreadsheet.integration.spec.ts
@@ -20,6 +20,7 @@ import {
BooleanNumber,
BorderStyleTypes,
createSheetGapTestConfig,
+ HorizontalAlign,
ILogService,
IUniverInstanceService,
LocaleType,
@@ -28,10 +29,12 @@ import {
RANGE_TYPE,
Univer,
UniverInstanceType,
+ VerticalAlign,
WrapStrategy,
} from '@univerjs/core';
import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
import { setupRenderTestEnv } from '../../../__tests__/render-test-utils';
+import { FontCache } from '../../../basics';
import { Vector2 } from '../../../basics/vector2';
import { Canvas } from '../../../canvas';
import { Engine } from '../../../engine';
@@ -512,8 +515,191 @@ describe('spreadsheet integration', () => {
noSkeletonSpreadsheet.dispose();
});
+ it('skips merge gridline cleanup during merge-free drawing', () => {
+ const { spreadsheet, skeleton, scene, cacheCanvas, mainCanvas } = fixture;
+ const context = mainCanvas.getContext() as any;
+ const extensionDraw = vi.fn();
+ vi.spyOn(skeleton.worksheet, 'getMergeData').mockReturnValue([]);
+ const getMergeRangesSpy = vi.spyOn(skeleton, 'getCurrentRowColumnSegmentMergeData');
+ vi.spyOn(spreadsheet as any, 'getExtensionsByOrder').mockReturnValue([{
+ uKey: 'MockSheetExtension',
+ draw: extensionDraw,
+ }]);
+
+ spreadsheet.draw(context, createViewportInfo(scene, cacheCanvas));
+
+ expect(getMergeRangesSpy).not.toHaveBeenCalled();
+ expect(extensionDraw.mock.calls.at(-1)?.[4].hasMergeData).toBe(false);
+ });
+
+ it('skips sparse extensions with no matching cell data during merge-free incremental drawing', () => {
+ const { spreadsheet, skeleton, scene, cacheCanvas, mainCanvas } = fixture;
+ const context = mainCanvas.getContext() as any;
+ const sparseDraw = vi.fn();
+ const regularDraw = vi.fn();
+
+ vi.spyOn(skeleton.worksheet, 'getMergeData').mockReturnValue([]);
+ vi.spyOn(skeleton.worksheet, 'getCell').mockReturnValue(undefined);
+ vi.spyOn(spreadsheet as any, 'getExtensionsByOrder').mockReturnValue([
+ {
+ draw: sparseDraw,
+ uKey: 'DefaultCustomExtension',
+ },
+ {
+ draw: regularDraw,
+ uKey: 'RegularExtension',
+ },
+ ]);
+
+ (spreadsheet as any)._refreshIncrementalState = true;
+ spreadsheet.draw(context, createViewportInfo(scene, cacheCanvas, {
+ diffBounds: [createBound(100, 60, 220, 140)],
+ diffCacheBounds: [createBound(100, 60, 220, 140)],
+ }));
+ (spreadsheet as any)._refreshIncrementalState = false;
+
+ expect(sparseDraw).not.toHaveBeenCalled();
+ expect(regularDraw).toHaveBeenCalledOnce();
+ });
+
+ it('does not skip conditional-formatting render extensions during sparse scans', () => {
+ const { spreadsheet, skeleton, scene, cacheCanvas, mainCanvas } = fixture;
+ const context = mainCanvas.getContext() as any;
+ const dataBarDraw = vi.fn();
+ const iconDraw = vi.fn();
+ const markerDraw = vi.fn();
+
+ vi.spyOn(skeleton.worksheet, 'getMergeData').mockReturnValue([]);
+ vi.spyOn(skeleton.worksheet, 'getCell').mockReturnValue(undefined);
+ vi.spyOn(spreadsheet as any, 'getExtensionsByOrder').mockReturnValue([
+ {
+ draw: dataBarDraw,
+ uKey: 'sheet-conditional-rule-data-bar',
+ },
+ {
+ draw: iconDraw,
+ uKey: 'sheet-conditional-rule-icon',
+ },
+ {
+ draw: markerDraw,
+ uKey: 'DefaultMarkerExtension',
+ },
+ ]);
+
+ (spreadsheet as any)._refreshIncrementalState = true;
+ spreadsheet.draw(context, createViewportInfo(scene, cacheCanvas, {
+ diffBounds: [createBound(100, 60, 220, 140)],
+ diffCacheBounds: [createBound(100, 60, 220, 140)],
+ }));
+ (spreadsheet as any)._refreshIncrementalState = false;
+
+ expect(dataBarDraw).toHaveBeenCalledOnce();
+ expect(iconDraw).toHaveBeenCalledOnce();
+ expect(markerDraw).not.toHaveBeenCalled();
+ });
+
+ it('does not scan sparse extension features when no sparse extension is registered', () => {
+ const { spreadsheet, skeleton, scene, cacheCanvas, mainCanvas } = fixture;
+ const context = mainCanvas.getContext() as any;
+ const regularDraw = vi.fn();
+ const getCellSpy = vi.spyOn(skeleton.worksheet, 'getCell');
+
+ vi.spyOn(skeleton.worksheet, 'getMergeData').mockReturnValue([]);
+ vi.spyOn(spreadsheet as any, 'getExtensionsByOrder').mockReturnValue([
+ {
+ draw: regularDraw,
+ uKey: 'RegularExtension',
+ },
+ ]);
+
+ (spreadsheet as any)._refreshIncrementalState = true;
+ spreadsheet.draw(context, createViewportInfo(scene, cacheCanvas, {
+ diffBounds: [createBound(100, 60, 220, 140)],
+ diffCacheBounds: [createBound(100, 60, 220, 140)],
+ }));
+ (spreadsheet as any)._refreshIncrementalState = false;
+
+ expect(regularDraw).toHaveBeenCalledOnce();
+ expect(getCellSpy).not.toHaveBeenCalled();
+ });
+
+ it('narrows sparse extension diff ranges to matching cells during merge-free incremental drawing', () => {
+ const { spreadsheet, skeleton, scene, cacheCanvas, mainCanvas } = fixture;
+ const context = mainCanvas.getContext() as any;
+ const markerDraw = vi.fn();
+
+ vi.spyOn(skeleton.worksheet, 'getMergeData').mockReturnValue([]);
+ vi.spyOn(skeleton.worksheet, 'getCell').mockImplementation((row: number, col: number) => (
+ row === 2 && col === 1 ? { markers: { tr: { color: '#ff0000', size: 4 } } } : undefined
+ ));
+ vi.spyOn(spreadsheet as any, 'getExtensionsByOrder').mockReturnValue([
+ {
+ draw: markerDraw,
+ uKey: 'DefaultMarkerExtension',
+ },
+ ]);
+
+ (spreadsheet as any)._refreshIncrementalState = true;
+ spreadsheet.draw(context, createViewportInfo(scene, cacheCanvas, {
+ diffBounds: [createBound(48, 48, 240, 120)],
+ diffCacheBounds: [createBound(48, 48, 240, 120)],
+ }));
+ (spreadsheet as any)._refreshIncrementalState = false;
+
+ expect(markerDraw).toHaveBeenCalledOnce();
+ expect(markerDraw.mock.calls[0][3]).toEqual([{
+ startRow: 2,
+ endRow: 2,
+ startColumn: 1,
+ endColumn: 1,
+ }]);
+ });
+
+ it('reuses style cache cell data when scanning sparse extension features', () => {
+ const { spreadsheet, skeleton, scene, cacheCanvas, mainCanvas } = fixture;
+ const context = mainCanvas.getContext() as any;
+ const markerDraw = vi.fn();
+ const diffBound = createBound(48, 48, 240, 120);
+ const diffRange = skeleton.getRangeByViewBound(diffBound);
+ const getCellSpy = vi.spyOn(skeleton.worksheet, 'getCell');
+
+ vi.spyOn(skeleton.worksheet, 'getMergeData').mockReturnValue([]);
+ for (let row = diffRange.startRow; row <= diffRange.endRow; row++) {
+ for (let col = diffRange.startColumn; col <= diffRange.endColumn; col++) {
+ skeleton.stylesCache.fontMatrix.setValue(row, col, {
+ cellData: row === 2 && col === 1
+ ? { markers: { tr: { color: '#ff0000', size: 4 } } }
+ : { v: `${row}-${col}` },
+ } as any);
+ }
+ }
+ vi.spyOn(spreadsheet as any, 'getExtensionsByOrder').mockReturnValue([
+ {
+ draw: markerDraw,
+ uKey: 'DefaultMarkerExtension',
+ },
+ ]);
+
+ (spreadsheet as any)._refreshIncrementalState = true;
+ spreadsheet.draw(context, createViewportInfo(scene, cacheCanvas, {
+ diffBounds: [diffBound],
+ diffCacheBounds: [diffBound],
+ }));
+ (spreadsheet as any)._refreshIncrementalState = false;
+
+ expect(getCellSpy).not.toHaveBeenCalled();
+ expect(markerDraw).toHaveBeenCalledOnce();
+ expect(markerDraw.mock.calls[0][3]).toEqual([{
+ startRow: 2,
+ endRow: 2,
+ startColumn: 1,
+ endColumn: 1,
+ }]);
+ });
+
it('skips style cache cell visits when scrolling inside the existing cache area', () => {
const { skeleton, scene, cacheCanvas } = fixture;
+ vi.spyOn(skeleton.worksheet, 'getMergeData').mockReturnValue([]);
const styleCellSpy = vi.spyOn(skeleton as any, '_setStylesCacheForOneCell');
const viewportInfo = createViewportInfo(scene, cacheCanvas, {
diffBounds: [createBound(100, 60, 220, 140)],
@@ -531,6 +717,178 @@ describe('spreadsheet integration', () => {
expect(skeleton.rowColumnSegment).toEqual(skeleton.getCacheRangeByViewport(viewportInfo));
});
+ it('skips merge lookups for one-cell style cache when merge data is absent', () => {
+ const { skeleton } = fixture;
+ const mergeInfoSpy = vi.spyOn(skeleton.worksheet, 'getCellInfoInMergeData');
+
+ (skeleton as any)._setStylesCacheForOneCell(0, 0, {
+ cacheItem: { bg: true, border: true },
+ hasMergeData: false,
+ });
+
+ expect(mergeInfoSpy).not.toHaveBeenCalled();
+ });
+
+ it('reuses row visibility from the style cache row scan', () => {
+ const { skeleton, scene, cacheCanvas } = fixture;
+ const getRowVisibleSpy = vi.spyOn(skeleton.worksheet, 'getRowVisible');
+ const viewportInfo = createViewportInfo(scene, cacheCanvas);
+
+ skeleton.setStylesCache(viewportInfo);
+
+ const visibleRange = skeleton.rowColumnSegment;
+ const visibleRowCount = visibleRange.endRow - visibleRange.startRow + 1;
+ expect(getRowVisibleSpy.mock.calls.length).toBeLessThan(visibleRowCount * 3);
+ });
+
+ it('reuses cached overflow-only font styles without reading cell data again', () => {
+ const { skeleton } = fixture;
+ const getCellSpy = vi.spyOn(skeleton.worksheet, 'getCell');
+ const getStyleSpy = vi.spyOn(skeleton.worksheet, 'getComposedCellStyleByCellData');
+ const options = { cacheItem: { bg: false, border: false }, reuseExisting: true };
+
+ (skeleton as any)._setStylesCacheForOneCell(0, 0, options);
+ const getCellCalls = getCellSpy.mock.calls.length;
+ const getStyleCalls = getStyleSpy.mock.calls.length;
+
+ (skeleton as any)._setStylesCacheForOneCell(0, 0, options);
+
+ expect(getCellSpy.mock.calls.length).toBe(getCellCalls);
+ expect(getStyleSpy.mock.calls.length).toBe(getStyleCalls);
+ });
+
+ it('reuses fully cached cell styles during incremental scrolling', () => {
+ const { skeleton } = fixture;
+ const getCellSpy = vi.spyOn(skeleton.worksheet, 'getCell');
+ const getStyleSpy = vi.spyOn(skeleton.worksheet, 'getComposedCellStyleByCellData');
+
+ (skeleton as any)._setStylesCacheForOneCell(0, 0, { cacheItem: { bg: true, border: true } });
+ const getCellCalls = getCellSpy.mock.calls.length;
+ const getStyleCalls = getStyleSpy.mock.calls.length;
+
+ (skeleton as any)._setStylesCacheForOneCell(0, 0, { cacheItem: { bg: true, border: true }, reuseExisting: true });
+
+ expect(getCellSpy.mock.calls.length).toBe(getCellCalls);
+ expect(getStyleSpy.mock.calls.length).toBe(getStyleCalls);
+ });
+
+ it('skips overflow boundary scanning when text fits in the current column', () => {
+ const { skeleton } = fixture;
+ const overflowBoundSpy = vi.spyOn(skeleton as any, '_getOverflowBound');
+ const fontCache = {
+ cellData: { v: 'A1' },
+ fontString: '12px Arial',
+ horizontalAlign: HorizontalAlign.LEFT,
+ verticalAlign: VerticalAlign.TOP,
+ wrapStrategy: WrapStrategy.OVERFLOW,
+ } as any;
+
+ const result = (skeleton as any)._calculateOverflowCell(0, 0, fontCache);
+
+ expect(result).toBe(true);
+ expect(fontCache.textFitsCurrentCell).toBe(true);
+ expect(overflowBoundSpy).not.toHaveBeenCalled();
+ });
+
+ it('skips overflow text measurement when the adjacent cell blocks overflow', () => {
+ const { skeleton } = fixture;
+ const measureSpy = vi.spyOn(FontCache, 'getMeasureText');
+ vi.spyOn(skeleton.worksheet, 'getCell').mockImplementation((row: number, col: number) => (
+ row === 0 && col === 1 ? { v: 'blocked' } as any : { v: 'long text' } as any
+ ));
+
+ const result = (skeleton as any)._calculateOverflowCell(0, 0, {
+ cellData: { v: 'this is a very long text that would normally be measured' },
+ fontString: '12px Arial',
+ horizontalAlign: HorizontalAlign.LEFT,
+ verticalAlign: VerticalAlign.TOP,
+ wrapStrategy: WrapStrategy.OVERFLOW,
+ });
+
+ expect(result).toBe(true);
+ expect(measureSpy).not.toHaveBeenCalled();
+ });
+
+ it('uses raw adjacent cell data to block overflow without worksheet reads', () => {
+ const { skeleton } = fixture;
+ const getCellSpy = vi.spyOn(skeleton.worksheet, 'getCell');
+ const measureSpy = vi.spyOn(FontCache, 'getMeasureText');
+
+ const result = (skeleton as any)._calculateOverflowCell(0, 0, {
+ cellData: { v: 'this is a very long text that would normally inspect the adjacent cell' },
+ fontString: '12px Arial',
+ horizontalAlign: HorizontalAlign.LEFT,
+ verticalAlign: VerticalAlign.TOP,
+ wrapStrategy: WrapStrategy.OVERFLOW,
+ });
+
+ expect(result).toBe(true);
+ expect(getCellSpy).not.toHaveBeenCalled();
+ expect(measureSpy).not.toHaveBeenCalled();
+ });
+
+ it('skips merge checks during overflow calculation when the sheet has no merged cells', () => {
+ const { skeleton } = fixture;
+ const mergeSpy = vi.spyOn(skeleton, 'intersectMergeRange');
+ vi.spyOn(skeleton.worksheet, 'getCell').mockImplementation((row: number, col: number) => (
+ row === 0 && col === 1 ? { v: 'blocked' } as any : { v: 'long text' } as any
+ ));
+
+ const result = (skeleton as any)._calculateOverflowCell(0, 0, {
+ cellData: { v: 'this is a very long text that would normally check merge ranges' },
+ fontString: '12px Arial',
+ horizontalAlign: HorizontalAlign.LEFT,
+ verticalAlign: VerticalAlign.TOP,
+ wrapStrategy: WrapStrategy.OVERFLOW,
+ }, false);
+
+ expect(result).toBe(true);
+ expect(mergeSpy).not.toHaveBeenCalled();
+ });
+
+ it('skips style cache work for sheet header viewports', () => {
+ const { spreadsheet, skeleton, scene, cacheCanvas, mainCanvas } = fixture;
+ const context = mainCanvas.getContext();
+ const styleCacheSpy = vi.spyOn(skeleton, 'setStylesCache');
+ const viewportInfo = createViewportInfo(scene, cacheCanvas, {
+ viewportKey: SHEET_VIEWPORT_KEY.VIEW_ROW_TOP,
+ });
+
+ spreadsheet.render(context, viewportInfo);
+
+ expect(styleCacheSpy).not.toHaveBeenCalled();
+ });
+
+ it('copies the full cache viewport so the first row and column remain visible', () => {
+ const { spreadsheet, skeleton, scene, cacheCanvas, mainCanvas } = fixture;
+ const context = mainCanvas.getContext() as any;
+ const applyCacheSpy = vi.spyOn(spreadsheet as any, '_applyCache').mockImplementation(() => {});
+ const viewportInfo = createViewportInfo(scene, cacheCanvas, {
+ diffBounds: [],
+ diffCacheBounds: [],
+ isDirty: 0,
+ isForceDirty: false,
+ viewPortPosition: createBound(10, 20, 410, 220),
+ });
+ spreadsheet.makeDirty(false);
+ spreadsheet.makeForceDirty(false);
+
+ spreadsheet.renderByViewports(context, viewportInfo, skeleton);
+
+ expect(applyCacheSpy).toHaveBeenCalledWith(
+ cacheCanvas,
+ context,
+ 12,
+ 8,
+ 400 + skeleton.rowHeaderWidthAndMarginLeft,
+ 200 + skeleton.columnHeaderHeightAndMarginTop,
+ 10,
+ 20,
+ 400 + skeleton.rowHeaderWidthAndMarginLeft,
+ 200 + skeleton.columnHeaderHeightAndMarginTop
+ );
+ });
+
it('refreshes cache instead of incremental painting for large scroll jumps', () => {
const { spreadsheet, skeleton, mainCanvas, cacheCanvas, scene } = fixture;
const context = mainCanvas.getContext();
@@ -555,6 +913,82 @@ describe('spreadsheet integration', () => {
expect(paintSpy).not.toHaveBeenCalled();
});
+ it('uses backing-store cache size when detecting large scroll jumps', () => {
+ const { spreadsheet, skeleton, mainCanvas, scene } = fixture;
+ const context = mainCanvas.getContext();
+ const cacheCanvas = new Canvas({ width: 700, height: 420, pixelRatio: 1.5 });
+ vi.spyOn(skeleton.worksheet, 'getMergeData').mockReturnValue([]);
+ context.setTransform(1.5, 0, 0, 1.5, 0, 0);
+ const viewportInfo = createViewportInfo(scene, cacheCanvas, {
+ diffBounds: [createBound(0, 360, 460, 640)],
+ diffCacheBounds: [createBound(0, 360, 460, 640)],
+ diffX: 0,
+ diffY: -360,
+ isDirty: 0,
+ isForceDirty: false,
+ shouldCacheUpdate: 1,
+ });
+ spreadsheet.makeDirty(false);
+ spreadsheet.makeForceDirty(false);
+
+ const paintSpy = vi.spyOn(spreadsheet, 'paintNewAreaForScrolling');
+ const refreshSpy = vi.spyOn(spreadsheet, 'refreshCacheCanvas');
+
+ spreadsheet.renderByViewports(context, viewportInfo, skeleton);
+
+ expect(paintSpy).toHaveBeenCalledOnce();
+ expect(refreshSpy).not.toHaveBeenCalled();
+ cacheCanvas.dispose();
+ });
+
+ it('refreshes cache for merged sheets while scrolling to keep merged text visible', () => {
+ const { spreadsheet, skeleton, mainCanvas, cacheCanvas, scene } = fixture;
+ const context = mainCanvas.getContext();
+ const viewportInfo = createViewportInfo(scene, cacheCanvas, {
+ diffBounds: [createBound(0, 360, 460, 640)],
+ diffCacheBounds: [],
+ diffX: 0,
+ diffY: -48,
+ isDirty: 0,
+ isForceDirty: false,
+ shouldCacheUpdate: 0,
+ });
+ spreadsheet.makeDirty(false);
+ spreadsheet.makeForceDirty(false);
+
+ const paintSpy = vi.spyOn(spreadsheet, 'paintNewAreaForScrolling');
+ const refreshSpy = vi.spyOn(spreadsheet, 'refreshCacheCanvas');
+
+ spreadsheet.renderByViewports(context, viewportInfo, skeleton);
+
+ expect(refreshSpy).toHaveBeenCalledOnce();
+ expect(paintSpy).not.toHaveBeenCalled();
+ });
+
+ it('refreshes cache for horizontal cache updates to avoid exposing stale cache edges', () => {
+ const { spreadsheet, skeleton, mainCanvas, cacheCanvas, scene } = fixture;
+ const context = mainCanvas.getContext();
+ const viewportInfo = createViewportInfo(scene, cacheCanvas, {
+ diffBounds: [createBound(520, 0, 640, 280)],
+ diffCacheBounds: [createBound(520, 0, 640, 280)],
+ diffX: -80,
+ diffY: 0,
+ isDirty: 0,
+ isForceDirty: false,
+ shouldCacheUpdate: 1,
+ });
+ spreadsheet.makeDirty(false);
+ spreadsheet.makeForceDirty(false);
+
+ const paintSpy = vi.spyOn(spreadsheet, 'paintNewAreaForScrolling');
+ const refreshSpy = vi.spyOn(spreadsheet, 'refreshCacheCanvas');
+
+ spreadsheet.renderByViewports(context, viewportInfo, skeleton);
+
+ expect(refreshSpy).toHaveBeenCalledOnce();
+ expect(paintSpy).not.toHaveBeenCalled();
+ });
+
it('draws row and column gap areas using defaults from gapConfig', () => {
const { spreadsheet, skeleton, mainCanvas } = fixture;
const context = mainCanvas.getContext() as any;
diff --git a/packages/engine-render/src/components/sheets/extensions/__tests__/background.spec.ts b/packages/engine-render/src/components/sheets/extensions/__tests__/background.spec.ts
index 4fc03a839d..95c8d85f84 100644
--- a/packages/engine-render/src/components/sheets/extensions/__tests__/background.spec.ts
+++ b/packages/engine-render/src/components/sheets/extensions/__tests__/background.spec.ts
@@ -129,6 +129,135 @@ describe('background extension', () => {
expect(bgByMatrix.forValue).toHaveBeenCalled();
});
+ it('reuses cached background cell positions when drawing backgrounds', () => {
+ const extension = new Background();
+ const ctx = createCtx();
+ const bgMatrix = createBgMatrix([[0, 0, '1']], 99);
+ const backgroundPositions = new ObjectMatrix();
+ backgroundPositions.setValue(0, 0, createCellInfo());
+
+ const skeleton = {
+ worksheet: {
+ getMergedCellRange: vi.fn(() => []),
+ getRowVisible: vi.fn(() => true),
+ getColVisible: vi.fn(() => true),
+ getSpanModel: vi.fn(() => ({
+ getMergeDataIndex: vi.fn(() => -1),
+ })),
+ },
+ stylesCache: {
+ background: { '#ff0000': bgMatrix },
+ backgroundPositions,
+ },
+ rowHeightAccumulation: [20],
+ columnWidthAccumulation: [40],
+ columnTotalWidth: 40,
+ rowTotalHeight: 20,
+ getCellByIndexWithNoHeader: vi.fn(() => createCellInfo()),
+ getCellWithCoordByIndex: vi.fn(() => createCellInfo()),
+ } as any;
+
+ extension.draw(
+ ctx,
+ { scaleX: 1, scaleY: 1 } as any,
+ skeleton,
+ [],
+ {
+ viewRanges: [{ startRow: 0, endRow: 0, startColumn: 0, endColumn: 0 }],
+ checkOutOfViewBound: true,
+ } as any
+ );
+
+ expect(skeleton.getCellByIndexWithNoHeader).not.toHaveBeenCalled();
+ expect(ctx.fill).toHaveBeenCalled();
+ });
+
+ it('skips merge lookups when drawing merge-free backgrounds', () => {
+ const extension = new Background();
+ const ctx = createCtx();
+ const bgMatrix = createBgMatrix([[0, 0, '1']], 99);
+ const getMergeDataIndex = vi.fn(() => -1);
+ const worksheet = {
+ getMergedCellRange: vi.fn(() => []),
+ getRowVisible: vi.fn(() => true),
+ getColVisible: vi.fn(() => true),
+ getSpanModel: vi.fn(() => ({
+ getMergeDataIndex,
+ })),
+ };
+ const skeleton = {
+ worksheet,
+ stylesCache: {
+ background: { '#ff0000': bgMatrix },
+ backgroundPositions: new ObjectMatrix(),
+ },
+ rowHeightAccumulation: [20],
+ columnWidthAccumulation: [40],
+ columnTotalWidth: 40,
+ rowTotalHeight: 20,
+ getCellByIndexWithNoHeader: vi.fn(() => createCellInfo()),
+ getCellWithCoordByIndex: vi.fn(() => createCellInfo()),
+ } as any;
+
+ extension.draw(
+ ctx,
+ { scaleX: 1, scaleY: 1 } as any,
+ skeleton,
+ [],
+ {
+ viewRanges: [{ startRow: 0, endRow: 0, startColumn: 0, endColumn: 0 }],
+ checkOutOfViewBound: true,
+ hasMergeData: false,
+ } as any
+ );
+
+ expect(worksheet.getMergedCellRange).not.toHaveBeenCalled();
+ expect(worksheet.getSpanModel).not.toHaveBeenCalled();
+ expect(getMergeDataIndex).not.toHaveBeenCalled();
+ expect(ctx.fill).toHaveBeenCalled();
+ });
+
+ it('uses diff ranges to choose background iteration during incremental drawing', () => {
+ const extension = new Background();
+ const ctx = createCtx();
+ const bgMatrix = createBgMatrix([[1, 1, '1']], 4);
+
+ const skeleton = {
+ worksheet: {
+ getMergedCellRange: vi.fn(() => []),
+ getRowVisible: vi.fn(() => true),
+ getColVisible: vi.fn(() => true),
+ getSpanModel: vi.fn(() => ({
+ getMergeDataIndex: vi.fn(() => -1),
+ })),
+ },
+ stylesCache: {
+ background: { '#ff0000': bgMatrix },
+ backgroundPositions: new ObjectMatrix(),
+ },
+ rowHeightAccumulation: [20, 40],
+ columnWidthAccumulation: [40, 80],
+ columnTotalWidth: 80,
+ rowTotalHeight: 40,
+ getCellByIndexWithNoHeader: vi.fn(() => createCellInfo()),
+ getCellWithCoordByIndex: vi.fn(() => createCellInfo()),
+ } as any;
+
+ extension.draw(
+ ctx,
+ { scaleX: 1, scaleY: 1 } as any,
+ skeleton,
+ [{ startRow: 1, endRow: 1, startColumn: 1, endColumn: 1 }],
+ {
+ viewRanges: [{ startRow: 0, endRow: 1, startColumn: 0, endColumn: 1 }],
+ checkOutOfViewBound: true,
+ } as any
+ );
+
+ expect(bgMatrix.forValue).not.toHaveBeenCalled();
+ expect(bgMatrix.getValue).toHaveBeenCalledWith(1, 1);
+ });
+
it('draws merged cell backgrounds and handles early draw exits', () => {
const extension = new Background();
const ctx = createCtx();
@@ -201,6 +330,14 @@ describe('background extension', () => {
const rowHidden = extension.renderBGByCell(bgContext, 0, 0);
expect(rowHidden).toBe(true);
+ skeleton.worksheet.getRowVisible = vi.fn(() => true);
+ bgContext.viewRanges = [{ startRow: 10, endRow: 10, startColumn: 10, endColumn: 10 }];
+ bgContext.skipRenderRangeCheck = true;
+ const skippedRangeCheck = extension.renderBGByCell(bgContext, 0, 0);
+ expect(skippedRangeCheck).toBeUndefined();
+ expect(rect).toHaveBeenCalled();
+ bgContext.skipRenderRangeCheck = false;
+
bgContext.cellInfo = createCellInfo({
isMergedMainCell: true,
mergeInfo: {
diff --git a/packages/engine-render/src/components/sheets/extensions/__tests__/font.spec.ts b/packages/engine-render/src/components/sheets/extensions/__tests__/font.spec.ts
index 8335b7272a..fb3327c1e2 100644
--- a/packages/engine-render/src/components/sheets/extensions/__tests__/font.spec.ts
+++ b/packages/engine-render/src/components/sheets/extensions/__tests__/font.spec.ts
@@ -32,6 +32,7 @@ function createCtx() {
rectByPrecision: vi.fn(),
drawImage: vi.fn(),
fillRectByPrecision: vi.fn(),
+ fillText: vi.fn(),
getScale: vi.fn(() => ({ scaleX: 1, scaleY: 1 })),
} as any;
}
@@ -86,6 +87,7 @@ function createSpreadsheetSkeleton() {
getRowVisible: vi.fn(() => true),
getColVisible: vi.fn(() => true),
getCell: vi.fn(() => ({ v: 'A', t: CellValueType.STRING })),
+ getMergeData: vi.fn(() => []),
getSpanModel: vi.fn(() => ({
getMergeDataIndex: vi.fn(() => -1),
})),
@@ -211,6 +213,7 @@ describe('font extension', () => {
it('covers text render alignment and wrap branches', () => {
const drawWithSpy = vi.spyOn(Text as any, 'drawWith').mockImplementation((..._args: any[]) => undefined);
+ const drawPlainSpy = vi.spyOn(Text as any, 'drawPlainWith').mockImplementation((..._args: any[]) => undefined);
const font = new Font() as any;
const ctx = createCtx();
const overflow = new ObjectMatrix<any>();
@@ -243,20 +246,40 @@ describe('font extension', () => {
cellData: { v: true, t: CellValueType.BOOLEAN },
});
font._renderText(ctx, 0, 0, renderFontCtx, overflow);
- expect(drawWithSpy).toHaveBeenLastCalledWith(
+ expect(drawPlainSpy).toHaveBeenLastCalledWith(
ctx,
expect.objectContaining({
hAlign: HorizontalAlign.CENTER,
+ text: 'TRUE',
+ warp: false,
+ })
+ );
+
+ renderFontCtx.fontCache = createFontCache({
+ horizontalAlign: HorizontalAlign.UNSPECIFIED,
+ resolvedHorizontalAlign: HorizontalAlign.LEFT,
+ displayText: 'cached text',
+ wrapStrategy: WrapStrategy.OVERFLOW,
+ cellData: { v: 123, t: CellValueType.NUMBER },
+ });
+ font._renderText(ctx, 0, 0, renderFontCtx, overflow);
+ expect(drawPlainSpy).toHaveBeenLastCalledWith(
+ ctx,
+ expect.objectContaining({
+ hAlign: HorizontalAlign.LEFT,
+ text: 'cached text',
warp: false,
})
);
const before = drawWithSpy.mock.calls.length;
+ const beforePlain = drawPlainSpy.mock.calls.length;
renderFontCtx.fontCache = createFontCache({
cellData: { v: null, t: CellValueType.STRING },
});
font._renderText(ctx, 0, 0, renderFontCtx, overflow);
expect(drawWithSpy.mock.calls.length).toBe(before);
+ expect(drawPlainSpy.mock.calls.length).toBe(beforePlain);
});
it('covers documents render branches and missing documents error', () => {
@@ -601,6 +624,151 @@ describe('font extension', () => {
expect(ctx.restore).toHaveBeenCalled();
});
+ it('does not read live cell data for plain cached font cells', () => {
+ const font = new Font() as any;
+ const ctx = createCtx();
+ const spreadsheetSkeleton = createSpreadsheetSkeleton();
+ const fontMatrix = new ObjectMatrix<any>();
+ fontMatrix.setValue(0, 0, createFontCache({
+ cellData: { v: 'text', t: CellValueType.STRING },
+ }));
+ const getCellSpy = vi.spyOn(spreadsheetSkeleton.worksheet, 'getCell');
+ vi.spyOn(font, '_renderText').mockImplementation(() => undefined);
+
+ const result = font._renderFontEachCell({
+ ctx,
+ scale: 1,
+ columnTotalWidth: 120,
+ rowTotalHeight: 60,
+ viewRanges: [{ startRow: 0, endRow: 0, startColumn: 0, endColumn: 0 }],
+ checkOutOfViewBound: true,
+ diffRanges: [],
+ spreadsheetSkeleton,
+ cellInfo: createCellInfo(),
+ } as any, 0, 0, fontMatrix);
+
+ expect(result).toBe(false);
+ expect(getCellSpy).not.toHaveBeenCalled();
+ });
+
+ it('draws fitting plain text without clipping', () => {
+ const font = new Font() as any;
+ const ctx = createCtx();
+ const spreadsheetSkeleton = createSpreadsheetSkeleton();
+ const fontMatrix = new ObjectMatrix<any>();
+ fontMatrix.setValue(0, 0, createFontCache({
+ cellData: { v: 123, t: CellValueType.NUMBER },
+ displayText: 'cached fit',
+ resolvedHorizontalAlign: HorizontalAlign.LEFT,
+ textFitsCurrentCell: true,
+ }));
+ const drawPlainSpy = vi.spyOn(Text, 'drawPlainWith').mockImplementation(() => 10);
+ const clipSpy = vi.spyOn(font, '_clipByRenderBounds').mockImplementation(() => undefined);
+ const renderTextSpy = vi.spyOn(font, '_renderText').mockImplementation(() => undefined);
+
+ const result = font._renderFontEachCell({
+ ctx,
+ scale: 1,
+ columnTotalWidth: 120,
+ rowTotalHeight: 60,
+ viewRanges: [{ startRow: 0, endRow: 0, startColumn: 0, endColumn: 0 }],
+ checkOutOfViewBound: true,
+ diffRanges: [],
+ spreadsheetSkeleton,
+ cellInfo: createCellInfo(),
+ } as any, 0, 0, fontMatrix);
+
+ expect(result).toBe(false);
+ expect(drawPlainSpy).toHaveBeenCalledOnce();
+ expect(drawPlainSpy).toHaveBeenCalledWith(
+ ctx,
+ expect.objectContaining({
+ text: 'cached fit',
+ hAlign: HorizontalAlign.LEFT,
+ })
+ );
+ expect(clipSpy).not.toHaveBeenCalled();
+ expect(renderTextSpy).not.toHaveBeenCalled();
+ expect(ctx.save).not.toHaveBeenCalled();
+ });
+
+ it('checks live cell data for cached font render extensions', () => {
+ const font = new Font() as any;
+ const ctx = createCtx();
+ const spreadsheetSkeleton = createSpreadsheetSkeleton();
+ const fontMatrix = new ObjectMatrix<any>();
+ fontMatrix.setValue(0, 0, createFontCache({
+ cellData: { v: 'text', t: CellValueType.STRING, fontRenderExtension: {} },
+ }));
+ vi.spyOn(spreadsheetSkeleton.worksheet, 'getCell').mockReturnValue({
+ v: 'text',
+ t: CellValueType.STRING,
+ fontRenderExtension: { isSkip: true },
+ } as any);
+ const renderTextSpy = vi.spyOn(font, '_renderText').mockImplementation(() => undefined);
+
+ const result = font._renderFontEachCell({
+ ctx,
+ scale: 1,
+ columnTotalWidth: 120,
+ rowTotalHeight: 60,
+ viewRanges: [{ startRow: 0, endRow: 0, startColumn: 0, endColumn: 0 }],
+ checkOutOfViewBound: true,
+ diffRanges: [],
+ spreadsheetSkeleton,
+ cellInfo: createCellInfo(),
+ } as any, 0, 0, fontMatrix);
+
+ expect(result).toBe(true);
+ expect(renderTextSpy).not.toHaveBeenCalled();
+ });
+
+ it('skips coordinate calculation for cells without font cache', () => {
+ const font = new Font() as any;
+ const ctx = createCtx();
+ const spreadsheetSkeleton = createSpreadsheetSkeleton();
+ const fontMatrix = new ObjectMatrix<any>();
+ fontMatrix.setValue(0, 0, createFontCache());
+ spreadsheetSkeleton.stylesCache = { fontMatrix };
+ spreadsheetSkeleton.columnTotalWidth = 120;
+ spreadsheetSkeleton.rowTotalHeight = 60;
+ const renderCellSpy = vi.spyOn(font, '_renderFontEachCell').mockReturnValue(true);
+
+ font.draw(ctx, { scaleX: 1, scaleY: 1 } as any, spreadsheetSkeleton, [], {
+ viewRanges: [{ startRow: 0, endRow: 1, startColumn: 0, endColumn: 1 }],
+ checkOutOfViewBound: true,
+ viewportKey: 'viewMain',
+ } as any);
+
+ expect(spreadsheetSkeleton.getCellWithCoordByIndex).toHaveBeenCalledOnce();
+ expect(spreadsheetSkeleton.getCellWithCoordByIndex).toHaveBeenCalledWith(0, 0, false);
+ expect(renderCellSpy).toHaveBeenCalledOnce();
+ });
+
+ it('skips merge lookup work when the sheet has no merged cells', () => {
+ const font = new Font() as any;
+ const ctx = createCtx();
+ const spreadsheetSkeleton = createSpreadsheetSkeleton();
+ const fontMatrix = new ObjectMatrix<any>();
+ fontMatrix.setValue(0, 0, createFontCache());
+ spreadsheetSkeleton.stylesCache = { fontMatrix };
+ spreadsheetSkeleton.columnTotalWidth = 120;
+ spreadsheetSkeleton.rowTotalHeight = 60;
+ const getSpanModelSpy = vi.spyOn(spreadsheetSkeleton.worksheet, 'getSpanModel');
+ const getMergedCellRangeSpy = vi.spyOn(spreadsheetSkeleton.worksheet, 'getMergedCellRange');
+ const renderCellSpy = vi.spyOn(font, '_renderFontEachCell').mockReturnValue(true);
+
+ font.draw(ctx, { scaleX: 1, scaleY: 1 } as any, spreadsheetSkeleton, [], {
+ viewRanges: [{ startRow: 0, endRow: 1, startColumn: 0, endColumn: 1 }],
+ checkOutOfViewBound: true,
+ viewportKey: 'viewMain',
+ } as any);
+
+ expect(getSpanModelSpy).not.toHaveBeenCalled();
+ expect(getMergedCellRangeSpy).not.toHaveBeenCalled();
+ expect(renderCellSpy).toHaveBeenCalledOnce();
+ });
+
it('does not mutate shared view ranges when expanding text overflow bounds', () => {
const font = new Font() as any;
const ctx = createCtx();
diff --git a/packages/engine-render/src/components/sheets/extensions/__tests__/marker.spec.ts b/packages/engine-render/src/components/sheets/extensions/__tests__/marker.spec.ts
index 0d508d4bcb..da3fc9da76 100644
--- a/packages/engine-render/src/components/sheets/extensions/__tests__/marker.spec.ts
+++ b/packages/engine-render/src/components/sheets/extensions/__tests__/marker.spec.ts
@@ -72,6 +72,7 @@ describe('marker extension', () => {
const ctx = createCtx();
const worksheet = {
+ getMergeData: vi.fn(() => []),
getRowVisible: vi.fn(() => true),
getColVisible: vi.fn(() => true),
getCell: vi.fn(() => ({
@@ -91,6 +92,13 @@ describe('marker extension', () => {
marker.draw(ctx, { scaleX: 1, scaleY: 1 } as any, skeleton, [{ startRow: 0, endRow: 0, startColumn: 0, endColumn: 0 }]);
expect(ctx.fill).toHaveBeenCalledTimes(4);
+ expect(ctx.save).not.toHaveBeenCalled();
+ expect(ctx.restore).not.toHaveBeenCalled();
+ expect(ctx.beginPath).toHaveBeenCalledTimes(4);
+ expect(ctx.moveTo).toHaveBeenCalledWith(10, 0);
+ expect(ctx.moveTo).toHaveBeenCalledWith(0, 0);
+ expect(ctx.moveTo).toHaveBeenCalledWith(10, 20);
+ expect(ctx.moveTo).toHaveBeenCalledWith(0, 20);
worksheet.getRowVisible.mockReturnValue(false);
marker.draw(ctx, { scaleX: 1, scaleY: 1 } as any, skeleton, [{ startRow: 0, endRow: 0, startColumn: 0, endColumn: 0 }]);
@@ -113,6 +121,12 @@ describe('marker extension', () => {
};
const worksheet = {
+ getMergeData: vi.fn(() => [{
+ startRow: 0,
+ endRow: 0,
+ startColumn: 0,
+ endColumn: 1,
+ }]),
getRowVisible: vi.fn(() => true),
getColVisible: vi.fn(() => true),
getCell: vi.fn(() => ({
@@ -144,6 +158,7 @@ describe('marker extension', () => {
const ctx = createCtx();
const worksheet = {
+ getMergeData: vi.fn(() => []),
getRowVisible: vi.fn(() => true),
getColVisible: vi.fn(() => true),
getCell: vi.fn((row: number) => row === 5
@@ -177,4 +192,25 @@ describe('marker extension', () => {
expect(worksheet.getCell).toHaveBeenCalledWith(5, 0);
expect(ctx.fill).toHaveBeenCalledTimes(1);
});
+
+ it('skips coordinate calculation for no-merge cells without markers', () => {
+ const marker = new Marker();
+ const ctx = createCtx();
+ const worksheet = {
+ getMergeData: vi.fn(() => []),
+ getRowVisible: vi.fn(() => true),
+ getColVisible: vi.fn(() => true),
+ getCell: vi.fn(() => ({ v: 'plain' })),
+ };
+ const skeleton = {
+ worksheet,
+ rowColumnSegment: { startRow: 0, endRow: 0, startColumn: 0, endColumn: 0 },
+ getCellWithCoordByIndex: vi.fn(() => createCellInfo()),
+ } as any;
+
+ marker.draw(ctx, { scaleX: 1, scaleY: 1 } as any, skeleton, [{ startRow: 0, endRow: 0, startColumn: 0, endColumn: 0 }]);
+
+ expect(skeleton.getCellWithCoordByIndex).not.toHaveBeenCalled();
+ expect(ctx.fill).not.toHaveBeenCalled();
+ });
});
diff --git a/packages/engine-render/src/components/sheets/extensions/background.ts b/packages/engine-render/src/components/sheets/extensions/background.ts
index 773cf8fdfe..086156b34a 100644
--- a/packages/engine-render/src/components/sheets/extensions/background.ts
+++ b/packages/engine-render/src/components/sheets/extensions/background.ts
@@ -33,6 +33,12 @@ const UNIQUE_KEY = 'DefaultBackgroundExtension';
const DOC_EXTENSION_Z_INDEX = 21;
const PRINTING_Z_INDEX = 21;
+function getRangeCellCount(ranges: IRange[]) {
+ return ranges.reduce((sum, range) => {
+ return sum + Math.max(range.endRow - range.startRow + 1, 0) * Math.max(range.endColumn - range.startColumn + 1, 0);
+ }, 0);
+}
+
interface IRenderBGContext {
ctx: UniverRenderingContext;
spreadsheetSkeleton: SpreadsheetSkeleton;
@@ -44,6 +50,7 @@ interface IRenderBGContext {
viewRanges: IRange[];
diffRanges: IRange[];
cellInfo: ICellWithCoord;
+ skipRenderRangeCheck?: boolean;
}
export class Background extends SheetExtension {
@@ -63,7 +70,7 @@ export class Background extends SheetExtension {
_parentScale: IScale,
spreadsheetSkeleton: SpreadsheetSkeleton,
diffRanges: IRange[],
- { viewRanges, checkOutOfViewBound }: IDrawInfo
+ { viewRanges, checkOutOfViewBound, hasMergeData = true }: IDrawInfo
) {
const { stylesCache, worksheet, rowHeightAccumulation, columnTotalWidth, columnWidthAccumulation, rowTotalHeight } = spreadsheetSkeleton;
const { background: bgMatrixCacheByColor, backgroundPositions } = stylesCache;
@@ -90,22 +97,27 @@ export class Background extends SheetExtension {
} as IRenderBGContext;
const mergeRanges: IRange[] = [];
- // Currently, viewRanges has only one range.
- viewRanges.forEach((range) => {
- // For merge cell.
- // The background extension is not as strict as the font extension; the font extension must never be redrawn. Therefore, it is not necessary to be that complex.
- const intersectMergeRangesInViewRanges = spreadsheetSkeleton.worksheet.getMergedCellRange(range.startRow, range.startColumn, range.endRow, range.endColumn);
- mergeRanges.push(...intersectMergeRangesInViewRanges);
- });
+ if (hasMergeData) {
+ // Currently, viewRanges has only one range.
+ viewRanges.forEach((range) => {
+ // For merge cell.
+ // The background extension is not as strict as the font extension; the font extension must never be redrawn. Therefore, it is not necessary to be that complex.
+ const intersectMergeRangesInViewRanges = spreadsheetSkeleton.worksheet.getMergedCellRange(range.startRow, range.startColumn, range.endRow, range.endColumn);
+ mergeRanges.push(...intersectMergeRangesInViewRanges);
+ });
+ }
const renderBGCore = (rgb: string) => {
const bgColorMatrix = bgMatrixCacheByColor[rgb];
+ const renderRanges = diffRanges && diffRanges.length > 0 ? diffRanges : viewRanges;
const rangeForEachFn = (row: number, col: number, bgConfigParam?: string) => {
- const index = spreadsheetSkeleton.worksheet.getSpanModel().getMergeDataIndex(row, col);
- if (index !== -1) {
- return;
+ if (hasMergeData) {
+ const index = spreadsheetSkeleton.worksheet.getSpanModel().getMergeDataIndex(row, col);
+ if (index !== -1) {
+ return;
+ }
}
- const cellInfo = spreadsheetSkeleton.getCellByIndexWithNoHeader(row, col);
+ const cellInfo = backgroundPositions?.getValue(row, col) ?? spreadsheetSkeleton.getCellByIndexWithNoHeader(row, col);
if (!cellInfo) return;
const bgConfig = bgConfigParam || bgColorMatrix.getValue(row, col);
if (bgConfig) {
@@ -120,17 +132,18 @@ export class Background extends SheetExtension {
ctx.beginPath();
const matrixSize = bgColorMatrix.getSizeOf();
- const cellCountInRanges = viewRanges.reduce((sum, range) => {
- return sum + (range.endRow - range.startRow) * (range.endColumn - range.startColumn);
- }, 0);
+ const cellCountInRanges = getRangeCellCount(renderRanges);
// if number of cells in range is over than bg config in matrix, renderBackground by matrix.
- // otherwise, renderBackground by cells in viewRange.
+ // otherwise, renderBackground by cells in render range.
if (cellCountInRanges < matrixSize) {
- // Currently, viewRanges has only one range.
- viewRanges.forEach((range) => {
+ // Currently, renderRanges has only one range in normal scrolling.
+ renderBGContext.skipRenderRangeCheck = true;
+ renderRanges.forEach((range) => {
Range.foreach(range, rangeForEachFn);
});
+ renderBGContext.skipRenderRangeCheck = false;
} else {
+ renderBGContext.skipRenderRangeCheck = false;
bgColorMatrix.forValue(rangeForEachFn);
}
ctx.fill(backgroundPaths);
@@ -162,13 +175,15 @@ export class Background extends SheetExtension {
for (let index = 0; index < rgbList.length; index++) {
const rgb = rgbList[index];
renderBGCore(rgb);
- renderBGForMergedCells(rgb);
+ if (hasMergeData) {
+ renderBGForMergedCells(rgb);
+ }
}
ctx.restore();
}
renderBGByCell(bgContext: IRenderBGContext, row: number, col: number) {
- const { spreadsheetSkeleton, backgroundPaths, scaleX, scaleY, viewRanges, diffRanges, cellInfo } = bgContext;
+ const { spreadsheetSkeleton, backgroundPaths, scaleX, scaleY, viewRanges, diffRanges, cellInfo, skipRenderRangeCheck } = bgContext;
let { startY, endY, startX, endX } = cellInfo;
const { isMerged, isMergedMainCell, mergeInfo } = cellInfo;
@@ -183,7 +198,7 @@ export class Background extends SheetExtension {
endX = mergeInfo.endX;
// If curr cell is not in the viewrange (viewport + merged cells), exit early.
- if ((!isMerged && !isMergedMainCell) && !inViewRanges(renderRange!, row, col)) {
+ if (!skipRenderRangeCheck && (!isMerged && !isMergedMainCell) && !inViewRanges(renderRange!, row, col)) {
return true;
}
diff --git a/packages/engine-render/src/components/sheets/extensions/font.ts b/packages/engine-render/src/components/sheets/extensions/font.ts
index 206537bbb6..b0f999f3d0 100644
--- a/packages/engine-render/src/components/sheets/extensions/font.ts
+++ b/packages/engine-render/src/components/sheets/extensions/font.ts
@@ -38,7 +38,6 @@ import {
CellValueType,
getDisplayValueFromCell,
HorizontalAlign,
- Range,
Tools,
VerticalAlign,
WrapStrategy,
@@ -63,6 +62,32 @@ function rotatedBoundingBox(width: number, height: number, angleDegrees: number)
return { rotatedWidth, rotatedHeight };
}
+function getResolvedRenderHorizontalAlign(fontCache: IFontCacheItem, cellData: ICellDataForSheetInterceptor): HorizontalAlign {
+ if (fontCache.resolvedHorizontalAlign !== undefined) {
+ return fontCache.resolvedHorizontalAlign;
+ }
+
+ const { horizontalAlign } = fontCache;
+ if (horizontalAlign !== HorizontalAlign.UNSPECIFIED) {
+ return horizontalAlign;
+ }
+
+ if (cellData.t === CellValueType.NUMBER || (!Tools.isDefine(cellData.t) && typeof cellData.v === 'number')) {
+ return HorizontalAlign.RIGHT;
+ }
+
+ if (cellData.t === CellValueType.BOOLEAN) {
+ return HorizontalAlign.CENTER;
+ }
+
+ return horizontalAlign;
+}
+
+function needsFontRenderExtensionBounds(fontCache: IFontCacheItem) {
+ const extension = fontCache.cellData?.fontRenderExtension;
+ return Boolean(extension?.isSkip || extension?.leftOffset || extension?.rightOffset);
+}
+
interface IRenderFontContext {
ctx: UniverRenderingContext;
scale: number;
@@ -153,7 +178,7 @@ export class Font extends SheetExtension {
}
const scale = this._getScale(parentScale);
- const { viewRanges = [], checkOutOfViewBound } = moreBoundsInfo;
+ const { fontRenderRanges, viewRanges = [], checkOutOfViewBound } = moreBoundsInfo;
const lastRowIndex = spreadsheetSkeleton.getRowCount() - 1;
const lastColIndex = spreadsheetSkeleton.getColumnCount() - 1;
const expandedViewRanges = viewRanges.map((range) => clampRange({
@@ -161,6 +186,7 @@ export class Font extends SheetExtension {
startColumn: range.startColumn - EXPAND_SIZE_FOR_RENDER_OVERFLOW,
endColumn: range.endColumn + EXPAND_SIZE_FOR_RENDER_OVERFLOW,
}, lastRowIndex, lastColIndex));
+ const rangesToScan = fontRenderRanges?.length ? fontRenderRanges : expandedViewRanges;
const renderFontContext = {
ctx,
scale,
@@ -168,59 +194,76 @@ export class Font extends SheetExtension {
columnTotalWidth,
// columnWidthAccumulation,
rowTotalHeight,
- viewRanges: expandedViewRanges,
+ viewRanges: fontRenderRanges?.length ? viewRanges : expandedViewRanges,
checkOutOfViewBound: checkOutOfViewBound || true,
diffRanges,
spreadsheetSkeleton,
} as IRenderFontContext;
ctx.save();
+ const mergeData = spreadsheetSkeleton.worksheet.getMergeData();
+ const hasMerge = mergeData.length > 0;
const uniqueMergeRanges: IRange[] = [];
- const mergeRangeIDSet = new Set();
+ const mergeRangeIDSet = hasMerge ? new Set() : null;
+ const spanModel = hasMerge ? spreadsheetSkeleton.worksheet.getSpanModel() : null;
// Currently, viewRanges has only one range.
- expandedViewRanges.forEach((range) => {
- // collect unique merge ranges intersect with view range.
- // The ranges in mergeRanges must be unique. Otherwise, the font will render, text redrawing causes jagged edges or artifacts.
- const intersectMergeRangesWithViewRanges = spreadsheetSkeleton.worksheet.getMergedCellRange(
- range.startRow,
- range.startColumn,
- range.endRow,
- range.endColumn
- );
- intersectMergeRangesWithViewRanges.forEach((mergeRange) => {
- const mergeRangeIndex = spreadsheetSkeleton.worksheet.getSpanModel().getMergeDataIndex(mergeRange.startRow, mergeRange.startColumn);
- if (!mergeRangeIDSet.has(mergeRangeIndex)) {
- mergeRangeIDSet.add(mergeRangeIndex);
- uniqueMergeRanges.push(mergeRange);
- }
- });
+ rangesToScan.forEach((range) => {
+ if (hasMerge && spanModel && mergeRangeIDSet) {
+ // collect unique merge ranges intersect with view range.
+ // The ranges in mergeRanges must be unique. Otherwise, the font will render, text redrawing causes jagged edges or artifacts.
+ const intersectMergeRangesWithViewRanges = spreadsheetSkeleton.worksheet.getMergedCellRange(
+ range.startRow,
+ range.startColumn,
+ range.endRow,
+ range.endColumn
+ );
+ intersectMergeRangesWithViewRanges.forEach((mergeRange) => {
+ const mergeRangeIndex = spanModel.getMergeDataIndex(mergeRange.startRow, mergeRange.startColumn);
+ if (!mergeRangeIDSet.has(mergeRangeIndex)) {
+ mergeRangeIDSet.add(mergeRangeIndex);
+ uniqueMergeRanges.push(mergeRange);
+ }
+ });
+ }
- Range.foreach(range, (row, col) => {
- const index = spreadsheetSkeleton.worksheet.getSpanModel().getMergeDataIndex(row, col);
- if (index !== -1) {
- return;
- }
- const cellInfo = spreadsheetSkeleton.getCellWithCoordByIndex(row, col, false);
- if (!cellInfo) {
- return;
- }
+ const { startRow, endRow, startColumn, endColumn } = range;
+ for (let row = startRow; row <= endRow; row++) {
+ for (let col = startColumn; col <= endColumn; col++) {
+ const fontCache = fontMatrix.getValue(row, col);
+ if (!fontCache) {
+ continue;
+ }
- renderFontContext.cellInfo = cellInfo;
- this._renderFontEachCell(renderFontContext, row, col, fontMatrix);
- });
+ if (spanModel && spanModel.getMergeDataIndex(row, col) !== -1) {
+ continue;
+ }
+ const cellInfo = spreadsheetSkeleton.getCellWithCoordByIndex(row, col, false);
+ if (!cellInfo) {
+ continue;
+ }
+
+ renderFontContext.cellInfo = cellInfo;
+ this._renderFontEachCell(renderFontContext, row, col, fontMatrix, fontCache);
+ }
+ }
});
uniqueMergeRanges.forEach((range) => {
+ const fontCache = fontMatrix.getValue(range.startRow, range.startColumn);
+ if (!fontCache) {
+ return;
+ }
+
const cellInfo = spreadsheetSkeleton.getCellWithCoordByIndex(range.startRow, range.startColumn, false);
renderFontContext.cellInfo = cellInfo;
- this._renderFontEachCell(renderFontContext, range.startRow, range.startColumn, fontMatrix);
+ this._renderFontEachCell(renderFontContext, range.startRow, range.startColumn, fontMatrix, fontCache);
});
ctx.restore();
}
- _renderFontEachCell(renderFontCtx: IRenderFontContext, row: number, col: number, fontMatrix: ObjectMatrix<IFontCacheItem>) {
+ _renderFontEachCell(renderFontCtx: IRenderFontContext, row: number, col: number, fontMatrix: ObjectMatrix<IFontCacheItem>, cacheValue?: IFontCacheItem) {
const { ctx, viewRanges, diffRanges, spreadsheetSkeleton, cellInfo } = renderFontCtx;
//#region merged cell
@@ -246,7 +289,7 @@ export class Font extends SheetExtension {
//#endregion
- const fontCache = fontMatrix.getValue(row, col);
+ const fontCache = cacheValue ?? fontMatrix.getValue(row, col);
if (!fontCache) return true;
renderFontCtx.fontCache = fontCache;
@@ -270,10 +313,14 @@ export class Font extends SheetExtension {
if (notInMergeRange) {
const visibleRow = spreadsheetSkeleton.worksheet.getRowVisible(row);
- if (!visibleRow) return true;
+ if (!visibleRow) {
+ return true;
+ }
const visibleCol = spreadsheetSkeleton.worksheet.getColVisible(col);
- if (!visibleCol) return true;
+ if (!visibleCol) {
+ return true;
+ }
} else {
let isAllRowHidden = true;
@@ -285,7 +332,9 @@ export class Font extends SheetExtension {
}
}
- if (isAllRowHidden) return true;
+ if (isAllRowHidden) {
+ return true;
+ }
let isAllColHidden = true;
@@ -297,15 +346,27 @@ export class Font extends SheetExtension {
}
}
- if (isAllColHidden) return true;
+ if (isAllColHidden) {
+ return true;
+ }
}
- // Since we cannot predict when fontRenderExtension?.isSkip might change,
- // we must check it every time and retrieve cell data directly from the worksheet,
- // not from the cache to ensure accuracy.
- const cellData = spreadsheetSkeleton.worksheet.getCell(row, col) as ICellDataForSheetInterceptor || {};
- if (cellData?.fontRenderExtension?.isSkip) {
- return true;
+ // For cells with render extensions, isSkip may be updated by render interceptors.
+ // Plain cells avoid the extra worksheet lookup on every scroll repaint.
+ if (fontCache.cellData?.fontRenderExtension) {
+ const cellData = spreadsheetSkeleton.worksheet.getCell(row, col) as ICellDataForSheetInterceptor || {};
+ if (cellData?.fontRenderExtension?.isSkip) {
+ return true;
+ }
+ }
+
+ if (this._renderPlainTextWithoutClip(ctx, renderFontCtx, fontCache)) {
+ renderFontCtx.startX = 0;
+ renderFontCtx.startY = 0;
+ renderFontCtx.endX = 0;
+ renderFontCtx.endY = 0;
+ renderFontCtx.overflowRectangle = null;
+ return false;
}
ctx.save();
@@ -322,7 +383,6 @@ export class Font extends SheetExtension {
} else {
this._renderText(ctx, row, col, renderFontCtx, spreadsheetSkeleton.overflowCache);
}
- ctx.closePath();
ctx.restore();
if (fontCache.documentSkeleton) {
@@ -345,6 +405,57 @@ export class Font extends SheetExtension {
return false;
};
+ private _renderPlainTextWithoutClip(ctx: UniverRenderingContext, renderFontCtx: IRenderFontContext, fontCache: IFontCacheItem) {
+ const { cellData, documentSkeleton, textFitsCurrentCell, vertexAngle = 0, centerAngle = 0, wrapStrategy } = fontCache;
+ if (!textFitsCurrentCell) {
+ return false;
+ }
+ if (documentSkeleton) {
+ return false;
+ }
+ if (vertexAngle !== 0 || centerAngle !== 0) {
+ return false;
+ }
+ if (wrapStrategy === WrapStrategy.WRAP) {
+ return false;
+ }
+ if (needsFontRenderExtensionBounds(fontCache)) {
+ return false;
+ }
+ if (fontCache.style?.st?.s || fontCache.style?.ul?.s) {
+ return false;
+ }
+ if (cellData?.v === undefined || cellData?.v === null) {
+ return false;
+ }
+
+ const padding = fontCache.style?.pd ?? DEFAULT_PADDING_DATA;
+ const paddingLeft = padding.l ?? DEFAULT_PADDING_DATA.l;
+ const paddingRight = padding.r ?? DEFAULT_PADDING_DATA.r;
+ const paddingTop = padding.t ?? DEFAULT_PADDING_DATA.t;
+ const paddingBottom = padding.b ?? DEFAULT_PADDING_DATA.b;
+ const text = fontCache.displayText ?? getDisplayValueFromCell(cellData);
+ const { startX, startY, endX, endY } = renderFontCtx;
+ const cellWidth = endX - startX - paddingLeft - paddingRight;
+ const cellHeight = endY - startY - paddingTop - paddingBottom;
+ const hAlign = getResolvedRenderHorizontalAlign(fontCache, cellData);
+
+ Text.drawPlainWith(ctx, {
+ text,
+ fontStyle: fontCache.fontString,
+ hAlign,
+ vAlign: fontCache.verticalAlign,
+ width: cellWidth,
+ height: cellHeight,
+ left: startX + FIX_ONE_PIXEL_BLUR_OFFSET + paddingLeft,
+ top: startY + FIX_ONE_PIXEL_BLUR_OFFSET + paddingTop,
+ color: fontCache.style?.cl?.rgb,
+ cellValueType: cellData.t,
+ });
+
+ return true;
+ }
+
private _renderImages(ctx: UniverRenderingContext, fontsConfig: IFontCacheItem, startX: number, startY: number, endX: number, endY: number) {
const { documentSkeleton, verticalAlign, horizontalAlign } = fontsConfig;
const PADDING = 2;
@@ -547,24 +658,13 @@ export class Font extends SheetExtension {
const paddingBottom = padding.b ?? DEFAULT_PADDING_DATA.b;
const { vertexAngle = 0, wrapStrategy, cellData } = fontCache;
if (cellData?.v === undefined || cellData?.v === null) return;
- const text = getDisplayValueFromCell(cellData);
+ const text = fontCache.displayText ?? getDisplayValueFromCell(cellData);
const { startX, startY, endX, endY } = renderFontCtx;
const cellWidth = endX - startX - paddingLeft - paddingRight;
const cellHeight = endY - startY - paddingTop - paddingBottom;
+ const hAlign = getResolvedRenderHorizontalAlign(fontCache, cellData);
- // If the horizontal alignment is not specified, we need to determine it based on the cell value type.
- let hAlign = fontCache.horizontalAlign;
- if (fontCache.horizontalAlign === HorizontalAlign.UNSPECIFIED) {
- if (cellData.t === CellValueType.NUMBER || (!Tools.isDefine(cellData.t) && typeof cellData.v === 'number')) {
- // If the cell value is a number, default to right alignment.
- hAlign = HorizontalAlign.RIGHT;
- } else if (cellData.t === CellValueType.BOOLEAN) {
- // If the cell value is a boolean, default to center alignment.
- hAlign = HorizontalAlign.CENTER;
- }
- }
-
- Text.drawWith(ctx, {
+ const textProps = {
text,
fontStyle: fontCache.fontString,
warp: wrapStrategy === WrapStrategy.WRAP && vertexAngle === 0,
@@ -579,7 +679,14 @@ export class Font extends SheetExtension {
underline: Boolean(fontCache.style?.ul?.s),
underlineType: fontCache.style?.ul?.t,
cellValueType: cellData.t,
- });
+ };
+
+ if (!textProps.warp && !textProps.strokeLine && !textProps.underline) {
+ Text.drawPlainWith(ctx, textProps);
+ return;
+ }
+
+ Text.drawWith(ctx, textProps);
}
private _renderDocuments(
diff --git a/packages/engine-render/src/components/sheets/extensions/marker.ts b/packages/engine-render/src/components/sheets/extensions/marker.ts
index c7bd086bfd..fdd58609cb 100644
--- a/packages/engine-render/src/components/sheets/extensions/marker.ts
+++ b/packages/engine-render/src/components/sheets/extensions/marker.ts
@@ -17,7 +17,6 @@
import type { IRange, IScale } from '@univerjs/core';
import type { UniverRenderingContext } from '../../../context';
import type { SpreadsheetSkeleton } from '../sheet.render-skeleton';
-import { Range } from '@univerjs/core';
import { SpreadsheetExtensionRegistry } from '../../extension';
import { SheetExtension } from './sheet-extension';
@@ -30,6 +29,16 @@ const stringifyRange = (range: IRange) => {
return `${startRow}-${endRow}-${startColumn}-${endColumn}`;
};
+function drawTriangleMarker(ctx: UniverRenderingContext, color: string, x: number, y: number, x2: number, y2: number, x3: number, y3: number) {
+ ctx.fillStyle = color;
+ ctx.beginPath();
+ ctx.moveTo(x, y);
+ ctx.lineTo(x2, y2);
+ ctx.lineTo(x3, y3);
+ ctx.closePath();
+ ctx.fill();
+}
+
export class Marker extends SheetExtension {
protected override Z_INDEX: number = Z_INDEX;
@@ -53,117 +62,87 @@ export class Marker extends SheetExtension {
const mergeCellRendered = new Set<string>();
const renderRanges = diffRanges?.length ? diffRanges : [rowColumnSegment];
+ const hasMerge = worksheet.getMergeData().length > 0;
- // eslint-disable-next-line max-lines-per-function
renderRanges.forEach((range) => {
- // eslint-disable-next-line max-lines-per-function
- Range.foreach(range, (row, col) => {
- if (!worksheet.getRowVisible(row) || !worksheet.getColVisible(col)) {
- return;
- }
+ const { startRow, endRow, startColumn, endColumn } = range;
+ for (let row = startRow; row <= endRow; row++) {
+ for (let col = startColumn; col <= endColumn; col++) {
+ if (!worksheet.getRowVisible(row) || !worksheet.getColVisible(col)) {
+ continue;
+ }
- let cellData = worksheet.getCell(row, col);
- const cellInfo = skeleton.getCellWithCoordByIndex(row, col, false);
- const { isMerged, isMergedMainCell, mergeInfo } = cellInfo;
- let { startY, endY, startX, endX } = cellInfo;
+ let cellData = worksheet.getCell(row, col);
+ if (!hasMerge && !cellData?.markers) {
+ continue;
+ }
- if (isMergedMainCell || isMerged) {
- startY = mergeInfo.startY;
- endY = mergeInfo.endY;
- startX = mergeInfo.startX;
- endX = mergeInfo.endX;
- }
+ const cellInfo = skeleton.getCellWithCoordByIndex(row, col, false);
+ const { isMerged, isMergedMainCell, mergeInfo } = cellInfo;
+ let { startY, endY, startX, endX } = cellInfo;
- if (isMerged) {
- const mainCell = {
- row: mergeInfo.startRow,
- col: mergeInfo.startColumn,
- };
+ if (isMergedMainCell || isMerged) {
+ startY = mergeInfo.startY;
+ endY = mergeInfo.endY;
+ startX = mergeInfo.startX;
+ endX = mergeInfo.endX;
+ }
- cellData = worksheet.getCell(mainCell.row, mainCell.col);
- }
+ if (isMerged) {
+ const mainCell = {
+ row: mergeInfo.startRow,
+ col: mergeInfo.startColumn,
+ };
- if (!this.isRenderDiffRangesByRow(mergeInfo.startRow, mergeInfo.endRow, diffRanges)) {
- return true;
- }
+ cellData = worksheet.getCell(mainCell.row, mainCell.col);
+ }
- if (cellInfo.isMerged || cellInfo.isMergedMainCell) {
- const rangeStr = stringifyRange(mergeInfo);
- if (mergeCellRendered.has(rangeStr)) {
- return;
+ if (!this.isRenderDiffRangesByRow(mergeInfo.startRow, mergeInfo.endRow, diffRanges)) {
+ continue;
}
- mergeCellRendered.add(rangeStr);
- }
+ if (cellInfo.isMerged || cellInfo.isMergedMainCell) {
+ const rangeStr = stringifyRange(mergeInfo);
+ if (mergeCellRendered.has(rangeStr)) {
+ continue;
+ }
- if (!cellData) {
- return;
- }
+ mergeCellRendered.add(rangeStr);
+ }
- if (cellData.markers?.tr) {
- ctx.save();
- const marker = cellData.markers.tr;
- const x = endX;
- const y = startY;
- ctx.fillStyle = marker.color;
- ctx.moveTo(x, y);
- ctx.beginPath();
- ctx.lineTo(x - marker.size, y);
- ctx.lineTo(x, y + marker.size);
- ctx.lineTo(x, y);
- ctx.closePath();
- ctx.fill();
- ctx.restore();
- }
+ if (!cellData) {
+ continue;
+ }
- if (cellData.markers?.tl) {
- ctx.save();
- const marker = cellData.markers.tl;
- const x = startX;
- const y = startY;
- ctx.fillStyle = marker.color;
- ctx.moveTo(x, y);
- ctx.beginPath();
- ctx.lineTo(x + marker.size, y);
- ctx.lineTo(x, y + marker.size);
- ctx.lineTo(x, y);
- ctx.closePath();
- ctx.fill();
- ctx.restore();
- }
+ if (cellData.markers?.tr) {
+ const marker = cellData.markers.tr;
+ const x = endX;
+ const y = startY;
+ drawTriangleMarker(ctx, marker.color, x, y, x - marker.size, y, x, y + marker.size);
+ }
- if (cellData.markers?.br) {
- ctx.save();
- const marker = cellData.markers.br;
- const x = endX;
- const y = endY;
- ctx.fillStyle = marker.color;
- ctx.moveTo(x, y);
- ctx.beginPath();
- ctx.lineTo(x - marker.size, y);
- ctx.lineTo(x, y - marker.size);
- ctx.lineTo(x, y);
- ctx.closePath();
- ctx.fill();
- ctx.restore();
- }
+ if (cellData.markers?.tl) {
+ const marker = cellData.markers.tl;
+ const x = startX;
+ const y = startY;
+ drawTriangleMarker(ctx, marker.color, x, y, x + marker.size, y, x, y + marker.size);
+ }
- if (cellData.markers?.bl) {
- ctx.save();
- const marker = cellData.markers.bl;
- const x = startX;
- const y = endY;
- ctx.fillStyle = marker.color;
- ctx.moveTo(x, y);
- ctx.beginPath();
- ctx.lineTo(x + marker.size, y);
- ctx.lineTo(x, y - marker.size);
- ctx.lineTo(x, y);
- ctx.closePath();
- ctx.fill();
- ctx.restore();
+ if (cellData.markers?.br) {
+ const marker = cellData.markers.br;
+ const x = endX;
+ const y = endY;
+ drawTriangleMarker(ctx, marker.color, x, y, x - marker.size, y, x, y - marker.size);
+ }
+
+ if (cellData.markers?.bl) {
+ const marker = cellData.markers.bl;
+ const x = startX;
+ const y = endY;
+ drawTriangleMarker(ctx, marker.color, x, y, x + marker.size, y, x, y - marker.size);
+ }
}
- });
+ }
});
}
}
diff --git a/packages/engine-render/src/components/sheets/interfaces.ts b/packages/engine-render/src/components/sheets/interfaces.ts
index a36455a47d..d9a94710fa 100644
--- a/packages/engine-render/src/components/sheets/interfaces.ts
+++ b/packages/engine-render/src/components/sheets/interfaces.ts
@@ -52,6 +52,9 @@ export interface IFontCacheItem {
cellData: Nullable<ICellDataForSheetInterceptor>;
fontString: string;
style?: Nullable<IStyleData>;
+ displayText?: string;
+ resolvedHorizontalAlign?: HorizontalAlign;
+ textFitsCurrentCell?: boolean;
}
type colorString = string;
diff --git a/packages/engine-render/src/components/sheets/sheet.render-skeleton.ts b/packages/engine-render/src/components/sheets/sheet.render-skeleton.ts
index 1593395cbe..5e8d80a867 100644
--- a/packages/engine-render/src/components/sheets/sheet.render-skeleton.ts
+++ b/packages/engine-render/src/components/sheets/sheet.render-skeleton.ts
@@ -54,6 +54,7 @@ import {
IContextService,
Inject,
Injector,
+ isCellCoverable,
isNullCell,
isWhiteColor,
LocaleService,
@@ -92,6 +93,7 @@ const DEFAULT_CELL_DOCUMENT_MODEL_OPTION: ICellDocumentModelOption = {
};
interface IRowColumnRange extends IRowRange, IColumnRange { }
+
export interface IDocumentLayoutObject {
documentModel: Nullable<DocumentDataModel>;
fontString: string;
@@ -112,11 +114,71 @@ export const DEFAULT_PADDING_DATA = {
export const RENDER_RAW_FORMULA_KEY = 'RENDER_RAW_FORMULA';
+function getResolvedRenderHorizontalAlign(
+ horizontalAlign: HorizontalAlign,
+ cellData: Nullable<ICellDataForSheetInterceptor>
+): HorizontalAlign {
+ if (horizontalAlign !== HorizontalAlign.UNSPECIFIED) {
+ return horizontalAlign;
+ }
+
+ if (cellData?.t === CellValueType.NUMBER || (!Tools.isDefine(cellData?.t) && typeof cellData?.v === 'number')) {
+ return HorizontalAlign.RIGHT;
+ }
+
+ if (cellData?.t === CellValueType.BOOLEAN) {
+ return HorizontalAlign.CENTER;
+ }
+
+ return horizontalAlign;
+}
+
+function setRenderTextCache(cacheItem: IFontCacheItem, cellData: Nullable<ICellDataForSheetInterceptor>): void {
+ if (cacheItem.documentSkeleton) {
+ cacheItem.displayText = undefined;
+ cacheItem.resolvedHorizontalAlign = undefined;
+ return;
+ }
+
+ cacheItem.displayText = getDisplayValueFromCell(cellData);
+ cacheItem.resolvedHorizontalAlign = getResolvedRenderHorizontalAlign(
+ cacheItem.horizontalAlign ?? HorizontalAlign.UNSPECIFIED,
+ cellData
+ );
+}
+
+function pushRowRange(ranges: IRange[], row: number, startColumn: number, endColumn: number): void {
+ if (endColumn < startColumn) {
+ return;
+ }
+
+ const last = ranges[ranges.length - 1];
+ if (last && last.startRow === row && last.endRow === row && last.endColumn + 1 === startColumn) {
+ last.endColumn = endColumn;
+ return;
+ }
+
+ ranges.push({
+ startRow: row,
+ endRow: row,
+ startColumn,
+ endColumn,
+ });
+}
+
export interface ICacheItem {
bg: boolean;
border: boolean;
}
+interface ISetStylesCacheForOneCellOptions {
+ mergeRange?: IRange;
+ cacheItem?: ICacheItem;
+ reuseExisting?: boolean;
+ hasMergeData?: boolean;
+ rowVisible?: boolean;
+}
+
export interface IGetPosByRowColOptions {
closeFirst?: boolean;
@@ -146,6 +208,8 @@ export class SpreadsheetSkeleton extends SheetSkeleton {
// private _dataMergeCache: IRange[] = [];
private _overflowCache: ObjectMatrix<IRange> = new ObjectMatrix();
+
+ private _incrementalFontRenderRanges: IRange[] = [];
private _stylesCache: IStylesCache = {
background: {},
backgroundPositions: new ObjectMatrix<ICellWithCoord>(),
@@ -235,6 +299,10 @@ export class SpreadsheetSkeleton extends SheetSkeleton {
return this._overflowCache;
}
+ get incrementalFontRenderRanges(): IRange[] {
+ return this._incrementalFontRenderRanges;
+ }
+
get showGridlines(): BooleanNumber {
return this._showGridlines;
}
@@ -359,9 +427,23 @@ export class SpreadsheetSkeleton extends SheetSkeleton {
!!vpInfo.diffX ||
!!vpInfo.diffY
);
- const styleRanges = isIncrementalScroll
+ const hasMergeData = this.worksheet.getMergeData().length > 0;
+ const isScrolling = !!vpInfo && (!!vpInfo.diffX || !!vpInfo.diffY);
+ const shouldRefreshCacheForScroll = isIncrementalScroll && (
+ (hasMergeData && isScrolling) ||
+ (!!vpInfo.shouldCacheUpdate && !!vpInfo.diffX)
+ );
+ const shouldUseIncrementalStyleRange = isIncrementalScroll && !shouldRefreshCacheForScroll;
+ const styleRanges = shouldUseIncrementalStyleRange
? (vpInfo.shouldCacheUpdate ? (vpInfo.diffCacheBounds?.map((bound) => this.getRangeByViewBound(bound)) ?? []) : [])
: [rowColumnSegment];
+ const visibleCellOptions: ISetStylesCacheForOneCellOptions | null = hasMergeData
+ ? null
+ : { cacheItem: { bg: true, border: true }, reuseExisting: shouldUseIncrementalStyleRange, hasMergeData, rowVisible: true };
+ const overflowCellOptions: ISetStylesCacheForOneCellOptions | null = hasMergeData
+ ? null
+ : { cacheItem: { bg: false, border: false }, reuseExisting: shouldUseIncrementalStyleRange, hasMergeData, rowVisible: true };
+ this._incrementalFontRenderRanges = [];
// clear cache out of visible range
// this._clearCacheOutOfVisibleRange(visibleStartRow, visibleEndRow, visibleStartColumn, visibleEndColumn);
@@ -401,18 +483,35 @@ export class SpreadsheetSkeleton extends SheetSkeleton {
}
for (let c = visibleStartColumn; c <= visibleEndColumn; c++) {
- this._setStylesCacheForOneCell(r, c, { cacheItem: { bg: true, border: true } });
+ this._setStylesCacheForOneCell(r, c, visibleCellOptions ?? { cacheItem: { bg: true, border: true }, reuseExisting: shouldUseIncrementalStyleRange, hasMergeData, rowVisible: true });
+ }
+ if (shouldUseIncrementalStyleRange) {
+ pushRowRange(this._incrementalFontRenderRanges, r, visibleStartColumn, visibleEndColumn);
}
- // Calculate the text length for overflow situations, focusing on the leftmost column within the visible range.
- for (let c = expandStartCol; c < visibleEndColumn; c++) {
- this._setStylesCacheForOneCell(r, c, { cacheItem: { bg: false, border: false } });
+ // Calculate text length for overflow cells just outside the visible range.
+ for (let c = visibleStartColumn - 1; c >= expandStartCol; c--) {
+ this._setStylesCacheForOneCell(r, c, overflowCellOptions ?? { cacheItem: { bg: false, border: false }, reuseExisting: shouldUseIncrementalStyleRange, hasMergeData, rowVisible: true });
+ if (shouldUseIncrementalStyleRange) {
+ pushRowRange(this._incrementalFontRenderRanges, r, c, c);
+ }
+ const cell = this.worksheet.getCell(r, c);
+ if (!isCellCoverable(cell) || (hasMergeData && this.intersectMergeRange(r, c))) {
+ break;
+ }
}
if (visibleEndColumn === 0) continue;
- // Calculate the text length for overflow situations, focusing on the rightmost column within the visible range.
- for (let c = visibleEndColumn + 1; c < expandEndCol; c++) {
- this._setStylesCacheForOneCell(r, c, { cacheItem: { bg: false, border: false } });
+ // Calculate text length for overflow cells just outside the visible range.
+ for (let c = visibleEndColumn + 1; c <= expandEndCol; c++) {
+ this._setStylesCacheForOneCell(r, c, overflowCellOptions ?? { cacheItem: { bg: false, border: false }, reuseExisting: shouldUseIncrementalStyleRange, hasMergeData, rowVisible: true });
+ if (shouldUseIncrementalStyleRange) {
+ pushRowRange(this._incrementalFontRenderRanges, r, c, c);
+ }
+ const cell = this.worksheet.getCell(r, c);
+ if (!isCellCoverable(cell) || (hasMergeData && this.intersectMergeRange(r, c))) {
+ break;
+ }
}
}
@@ -424,7 +523,12 @@ export class SpreadsheetSkeleton extends SheetSkeleton {
for (const mergeRange of mergeRanges) {
this._setStylesCacheForOneCell(mergeRange.startRow, mergeRange.startColumn, {
mergeRange,
+ reuseExisting: shouldUseIncrementalStyleRange,
+ hasMergeData,
});
+ if (shouldUseIncrementalStyleRange) {
+ pushRowRange(this._incrementalFontRenderRanges, mergeRange.startRow, mergeRange.startColumn, mergeRange.startColumn);
+ }
}
}
@@ -887,6 +991,37 @@ export class SpreadsheetSkeleton extends SheetSkeleton {
};
}
+ private _isOverflowBlockedByAdjacentCell(row: number, column: number, horizontalAlign: HorizontalAlign, hasMergeData = true): boolean {
+ const leftBlocked = () => this._isOverflowSideBlocked(row, column, -1, hasMergeData);
+ const rightBlocked = () => this._isOverflowSideBlocked(row, column, 1, hasMergeData);
+
+ if (horizontalAlign === HorizontalAlign.CENTER) {
+ return leftBlocked() && rightBlocked();
+ }
+
+ if (horizontalAlign === HorizontalAlign.RIGHT) {
+ return leftBlocked();
+ }
+
+ return rightBlocked();
+ }
+
+ private _isOverflowSideBlocked(row: number, column: number, direction: -1 | 1, hasMergeData = true): boolean {
+ const adjacentColumn = column + direction;
+ if (adjacentColumn < 0 || adjacentColumn >= this.getColumnCount()) {
+ return true;
+ }
+
+ const rawAdjacentCell = this._cellData.getValue(row, adjacentColumn);
+ if (rawAdjacentCell && !isCellCoverable(rawAdjacentCell)) {
+ return true;
+ }
+
+ const cachedAdjacentCell = this._stylesCache.fontMatrix.getValue(row, adjacentColumn)?.cellData;
+ const adjacentCell = cachedAdjacentCell ?? this.worksheet.getCell(row, adjacentColumn);
+ return !isCellCoverable(adjacentCell) || (hasMergeData && this.intersectMergeRange(row, adjacentColumn));
+ }
+
/**
* Get cell by pos(offsetX, offsetY).
* @deprecated Please use `getCellWithCoordByOffset` instead.
@@ -1120,7 +1255,7 @@ export class SpreadsheetSkeleton extends SheetSkeleton {
* Overflow on the left or right is aligned according to the text's horizontal alignment.
*/
// eslint-disable-next-line complexity, max-lines-per-function
- private _calculateOverflowCell(row: number, column: number, docsConfig: IFontCacheItem): boolean {
+ private _calculateOverflowCell(row: number, column: number, docsConfig: IFontCacheItem, hasMergeData = true): boolean {
// wrap and angle handler
const { documentSkeleton, vertexAngle = 0, centerAngle = 0, horizontalAlign, wrapStrategy } = docsConfig;
const cell = this._cellData.getValue(row, column);
@@ -1137,7 +1272,6 @@ export class SpreadsheetSkeleton extends SheetSkeleton {
horizontalAlignPos = HorizontalAlign.RIGHT;
}
}
-
/**
* Numerical and Boolean values are not displayed with overflow.
*/
@@ -1147,8 +1281,18 @@ export class SpreadsheetSkeleton extends SheetSkeleton {
cellValueType !== CellValueType.BOOLEAN &&
horizontalAlign !== HorizontalAlign.JUSTIFIED
) {
+ docsConfig.textFitsCurrentCell = false;
// Merged cells do not support overflow.
- if (this.intersectMergeRange(row, column)) {
+ if (hasMergeData && this.intersectMergeRange(row, column)) {
+ return true;
+ }
+
+ const columnStart = this.columnWidthAccumulation[column - 1] || 0;
+ const columnEnd = this.columnWidthAccumulation[column] || columnStart;
+ const currentColumnWidth = columnEnd - columnStart;
+ const rawText = docsConfig.cellData?.p?.body?.dataStream ?? docsConfig.cellData?.v;
+ const mayOverflowCurrentColumn = Boolean(documentSkeleton) || `${rawText ?? ''}`.length * 4 > currentColumnWidth;
+ if (mayOverflowCurrentColumn && this._isOverflowBlockedByAdjacentCell(row, column, horizontalAlignPos, hasMergeData)) {
return true;
}
@@ -1184,6 +1328,11 @@ export class SpreadsheetSkeleton extends SheetSkeleton {
}
}
+ if (contentSize.width < currentColumnWidth) {
+ docsConfig.textFitsCurrentCell = true;
+ return true;
+ }
+
const position = this.getOverflowPosition(contentSize, horizontalAlignPos, row, column, this.getColumnCount());
const { startColumn, endColumn } = position;
@@ -1195,7 +1344,7 @@ export class SpreadsheetSkeleton extends SheetSkeleton {
this.appendToOverflowCache(row, column, startColumn, endColumn);
} else if (wrapStrategy === WrapStrategy.WRAP && vertexAngle !== 0) {
// Merged cells do not support overflow.
- if (this.intersectMergeRange(row, column)) {
+ if (hasMergeData && this.intersectMergeRange(row, column)) {
return true;
}
@@ -1338,15 +1487,19 @@ export class SpreadsheetSkeleton extends SheetSkeleton {
const range = ranges[i];
Range.foreach(range, (row, col) => {
this._stylesCache.fontMatrix.realDeleteValue(row, col);
+ this._stylesCache.border?.realDeleteValue(row, col);
+ this._stylesCache.backgroundPositions?.realDeleteValue(row, col);
+ this._handleBgMatrix.realDeleteValue(row, col);
+ this._handleBorderMatrix.realDeleteValue(row, col);
+ Object.values(this._stylesCache.background ?? {}).forEach((backgroundMatrix) => {
+ backgroundMatrix.realDeleteValue(row, col);
+ });
});
}
this.makeDirty(true);
}
- _setBorderStylesCache(row: number, col: number, style: Nullable<IStyleData>, options: {
- mergeRange?: IRange;
- cacheItem?: ICacheItem;
- } | undefined) {
+ _setBorderStylesCache(row: number, col: number, style: Nullable<IStyleData>, options: ISetStylesCacheForOneCellOptions | undefined) {
const handledThisCell = Tools.isDefine(this._handleBorderMatrix.getValue(row, col));
if (handledThisCell && !options?.mergeRange) return;
// by default, style cache should includes border and background info.
@@ -1377,10 +1530,7 @@ export class SpreadsheetSkeleton extends SheetSkeleton {
}
}
- _setBgStylesCache(row: number, col: number, style: Nullable<IStyleData>, options: {
- mergeRange?: IRange;
- cacheItem?: ICacheItem;
- } | undefined) {
+ _setBgStylesCache(row: number, col: number, style: Nullable<IStyleData>, options: ISetStylesCacheForOneCellOptions | undefined) {
const handledThisCell = Tools.isDefine(this._handleBgMatrix.getValue(row, col));
if (handledThisCell) return;
// by default, style cache should includes border and background info.
@@ -1401,7 +1551,7 @@ export class SpreadsheetSkeleton extends SheetSkeleton {
}
}
- _setFontStylesCache(row: number, col: number, cellData: Nullable<ICellDataForSheetInterceptor>, style: IStyleData) {
+ _setFontStylesCache(row: number, col: number, cellData: Nullable<ICellDataForSheetInterceptor>, style: IStyleData, hasMergeData = true) {
if (isNullCell(cellData)) return;
let config: Partial<IFontCacheItem> = {
@@ -1415,6 +1565,7 @@ export class SpreadsheetSkeleton extends SheetSkeleton {
} else {
const cacheItem = cacheValue as IFontCacheItem;
cacheItem.cellData = cellData;
+ setRenderTextCache(cacheItem, cellData);
this._stylesCache.fontMatrix.setValue(row, col, cacheValue as IFontCacheItem);
return;
}
@@ -1464,8 +1615,10 @@ export class SpreadsheetSkeleton extends SheetSkeleton {
style,
};
}
- this._calculateOverflowCell(row, col, config as IFontCacheItem);
- this._stylesCache.fontMatrix.setValue(row, col, config as IFontCacheItem);
+ const fontCacheItem = config as IFontCacheItem;
+ setRenderTextCache(fontCacheItem, cellData);
+ this._calculateOverflowCell(row, col, fontCacheItem, hasMergeData);
+ this._stylesCache.fontMatrix.setValue(row, col, fontCacheItem);
}
/**
@@ -1474,7 +1627,7 @@ export class SpreadsheetSkeleton extends SheetSkeleton {
* @param col {number}
* @param options {{ mergeRange: IRange; cacheItem: ICacheItem } | undefined}
*/
- private _setStylesCacheForOneCell(row: number, col: number, options: { mergeRange?: IRange; cacheItem?: ICacheItem }): void {
+ private _setStylesCacheForOneCell(row: number, col: number, options: ISetStylesCacheForOneCellOptions): void {
// when row/col would be negative ?
if (row === -1 || col === -1) {
return;
@@ -1492,13 +1645,30 @@ export class SpreadsheetSkeleton extends SheetSkeleton {
options = { cacheItem: { bg: true, border: true } };
}
- const { isMerged, isMergedMainCell, startRow, startColumn, endRow, endColumn } = this.worksheet.getCellInfoInMergeData(row, col);
+ const cacheItem = options.cacheItem;
+ if (options.reuseExisting && cacheItem && !options.mergeRange) {
+ const bgHandled = !cacheItem.bg || Tools.isDefine(this._handleBgMatrix.getValue(row, col));
+ const borderHandled = !cacheItem.border || Tools.isDefine(this._handleBorderMatrix.getValue(row, col));
+ if (bgHandled && borderHandled && this._stylesCache.fontMatrix.getValue(row, col)) {
+ return;
+ }
+ }
- if (isMerged) {
- options.mergeRange = { startRow, startColumn, endRow, endColumn };
+ const hasMergeData = options.hasMergeData ?? true;
+ let isMerged = false;
+ let isMergedMainCell = false;
+ if (hasMergeData) {
+ const mergeInfo = this.worksheet.getCellInfoInMergeData(row, col);
+ isMerged = mergeInfo.isMerged;
+ isMergedMainCell = mergeInfo.isMergedMainCell;
+ if (isMerged) {
+ const { startRow, startColumn, endRow, endColumn } = mergeInfo;
+ options.mergeRange = { startRow, startColumn, endRow, endColumn };
+ }
}
- const hidden = this.worksheet.getColVisible(col) === false || this.worksheet.getRowVisible(row) === false;
+ const rowVisible = options.rowVisible ?? this.worksheet.getRowVisible(row);
+ const hidden = this.worksheet.getColVisible(col) === false || rowVisible === false;
// hidden and not in mergeRange return.
if (hidden) {
@@ -1517,7 +1687,7 @@ export class SpreadsheetSkeleton extends SheetSkeleton {
this._setBgStylesCache(row, col, style, options);
this._setBorderStylesCache(row, col, style, options);
- this._setFontStylesCache(row, col, { ...cell, ...{ s: style } }, style);
+ this._setFontStylesCache(row, col, { ...cell, ...{ s: style } }, style, options.hasMergeData ?? true);
}
/**
diff --git a/packages/engine-render/src/components/sheets/spreadsheet.ts b/packages/engine-render/src/components/sheets/spreadsheet.ts
index 5eb758e44c..6f3a485159 100644
--- a/packages/engine-render/src/components/sheets/spreadsheet.ts
+++ b/packages/engine-render/src/components/sheets/spreadsheet.ts
@@ -38,6 +38,138 @@ import { SheetComponent } from './sheet-component';
const OBJECT_KEY = '__SHEET_EXTENSION_FONT_DOCUMENT_INSTANCE__';
+interface ISparseExtensionFeatureFlags {
+ hasCustomRender: boolean;
+ hasMarkers: boolean;
+ hasSelectionProtection: boolean;
+ customRenderRanges: IRange[];
+ markerRanges: IRange[];
+ selectionProtectionRanges: IRange[];
+}
+
+function pushSparseCellRange(ranges: IRange[], row: number, col: number) {
+ const last = ranges[ranges.length - 1];
+ if (last && last.startRow === row && last.endRow === row && last.endColumn + 1 === col) {
+ last.endColumn = col;
+ return;
+ }
+
+ ranges.push({
+ startRow: row,
+ endRow: row,
+ startColumn: col,
+ endColumn: col,
+ });
+}
+
+function scanSparseExtensionFeatures(spreadsheetSkeleton: SpreadsheetSkeleton, ranges: IRange[]): ISparseExtensionFeatureFlags | null {
+ const { worksheet } = spreadsheetSkeleton;
+ if (!worksheet || !ranges.length || worksheet.getMergeData().length > 0) {
+ return null;
+ }
+ const flags: ISparseExtensionFeatureFlags = {
+ hasCustomRender: false,
+ hasMarkers: false,
+ hasSelectionProtection: false,
+ customRenderRanges: [],
+ markerRanges: [],
+ selectionProtectionRanges: [],
+ };
+
+ for (const range of ranges) {
+ for (let row = range.startRow; row <= range.endRow; row++) {
+ if (!worksheet.getRowVisible(row)) {
+ continue;
+ }
+
+ for (let col = range.startColumn; col <= range.endColumn; col++) {
+ if (!worksheet.getColVisible(col)) {
+ continue;
+ }
+
+ const cachedCell = spreadsheetSkeleton.stylesCache.fontMatrix.getValue(row, col)?.cellData as Nullable<{
+ customRender?: unknown[];
+ markers?: unknown;
+ selectionProtection?: unknown[];
+ }>;
+ const cell = cachedCell ?? (worksheet.getCell(row, col) as Nullable<{
+ customRender?: unknown[];
+ markers?: unknown;
+ selectionProtection?: unknown[];
+ }>);
+ if (!cell) {
+ continue;
+ }
+
+ if (cell.customRender?.length) {
+ flags.hasCustomRender = true;
+ pushSparseCellRange(flags.customRenderRanges, row, col);
+ }
+ if (cell.markers) {
+ flags.hasMarkers = true;
+ pushSparseCellRange(flags.markerRanges, row, col);
+ }
+ if (cell.selectionProtection?.length) {
+ flags.hasSelectionProtection = true;
+ pushSparseCellRange(flags.selectionProtectionRanges, row, col);
+ }
+ }
+ }
+ }
+
+ return flags;
+}
+
+function shouldSkipSparseExtension(uKey: string, flags: ISparseExtensionFeatureFlags | null) {
+ if (!flags) {
+ return false;
+ }
+
+ switch (uKey) {
+ case 'DefaultCustomExtension':
+ return !flags.hasCustomRender;
+ case 'DefaultMarkerExtension':
+ return !flags.hasMarkers;
+ case 'RANGE_PROTECTION_CAN_VIEW_RENDER_EXTENSION_KEY':
+ case 'RANGE_PROTECTION_CAN_NOT_VIEW_RENDER_EXTENSION_KEY':
+ return !flags.hasSelectionProtection;
+ default:
+ return false;
+ }
+}
+
+function hasSparseExtension(extensions: Array<{ uKey: string }>) {
+ return extensions.some((extension) => {
+ switch (extension.uKey) {
+ case 'DefaultCustomExtension':
+ case 'DefaultMarkerExtension':
+ case 'RANGE_PROTECTION_CAN_VIEW_RENDER_EXTENSION_KEY':
+ case 'RANGE_PROTECTION_CAN_NOT_VIEW_RENDER_EXTENSION_KEY':
+ return true;
+ default:
+ return false;
+ }
+ });
+}
+
+function getSparseExtensionDiffRanges(uKey: string, flags: ISparseExtensionFeatureFlags | null, diffRanges: IRange[]) {
+ if (!flags) {
+ return diffRanges;
+ }
+
+ switch (uKey) {
+ case 'DefaultCustomExtension':
+ return flags.customRenderRanges;
+ case 'DefaultMarkerExtension':
+ return flags.markerRanges;
+ case 'RANGE_PROTECTION_CAN_VIEW_RENDER_EXTENSION_KEY':
+ case 'RANGE_PROTECTION_CAN_NOT_VIEW_RENDER_EXTENSION_KEY':
+ return flags.selectionProtectionRanges;
+ default:
+ return diffRanges;
+ }
+}
+
export class Spreadsheet extends SheetComponent {
private _backgroundExtension!: Background;
@@ -113,7 +245,8 @@ export class Spreadsheet extends SheetComponent {
if (!spreadsheetSkeleton) {
return;
}
- this._drawAuxiliary(ctx);
+ const hasMergeData = spreadsheetSkeleton.worksheet.getMergeData().length > 0;
+ this._drawAuxiliary(ctx, hasMergeData);
const parentScale = this.getParentScale();
const diffRanges = this._refreshIncrementalState && viewportInfo.diffBounds
@@ -132,18 +265,28 @@ export class Spreadsheet extends SheetComponent {
}))
: viewRanges;
const extensions = this.getExtensionsByOrder();
+ const sparseExtensionFeatures = !hasMergeData && hasSparseExtension(extensions)
+ ? scanSparseExtensionFeatures(spreadsheetSkeleton, viewRanges)
+ : null;
// At this moment, ctx.transform is at topLeft of sheet content, cell(0, 0)
const scene = this.getScene();
for (const extension of extensions) {
+ if (shouldSkipSparseExtension(extension.uKey, sparseExtensionFeatures)) {
+ continue;
+ }
+
const extensionViewRanges = extension === this._fontExtension || extension === this._borderExtension
? overflowSafeViewRanges
: viewRanges;
+ const extensionDiffRanges = getSparseExtensionDiffRanges(extension.uKey, sparseExtensionFeatures, diffRanges);
const timeKey = `${SHEET_EXTENSION_PREFIX}${extension.uKey}`;
const st = Tools.now();
- extension.draw(ctx, parentScale, spreadsheetSkeleton, diffRanges, {
+ extension.draw(ctx, parentScale, spreadsheetSkeleton, extensionDiffRanges, {
viewRanges: extensionViewRanges,
checkOutOfViewBound: true,
+ fontRenderRanges: extension === this._fontExtension ? spreadsheetSkeleton.incrementalFontRenderRanges : undefined,
+ hasMergeData,
viewportKey: viewportInfo.viewportKey,
viewBound: viewportInfo.cacheBound,
diffBounds: viewportInfo.diffBounds,
@@ -252,7 +395,7 @@ export class Spreadsheet extends SheetComponent {
}
renderByViewports(mainCtx: UniverRenderingContext2D, viewportInfo: IViewportInfo, spreadsheetSkeleton: SpreadsheetSkeleton) {
- const { diffBounds, diffX, diffY, viewPortPosition, cacheCanvas, leftOrigin, topOrigin, bufferEdgeX, bufferEdgeY, isDirty: isViewportDirty, isForceDirty: isViewportForceDirty } = viewportInfo as Required<IViewportInfo>;
+ const { diffBounds, diffX, diffY, viewPortPosition, cacheCanvas, leftOrigin, topOrigin, bufferEdgeX, bufferEdgeY, isDirty: isViewportDirty, isForceDirty: isViewportForceDirty, shouldCacheUpdate } = viewportInfo as Required<IViewportInfo>;
const { rowHeaderWidthAndMarginLeft, columnHeaderHeightAndMarginTop } = spreadsheetSkeleton;
const { a: scaleX = 1, d: scaleY = 1 } = mainCtx.getTransform();
const bufferEdgeSizeX = bufferEdgeX * scaleX / window.devicePixelRatio;
@@ -263,10 +406,13 @@ export class Spreadsheet extends SheetComponent {
const isForceDirty = isViewportForceDirty || this.isForceDirty();
const isDirty = isViewportDirty || this.isDirty();
+ const cachePixelRatio = cacheCanvas.getPixelRatio();
const isScrollJumpOutsideCache =
- Math.abs(diffX) * scaleX >= cacheCanvas.getWidth() ||
- Math.abs(diffY) * scaleY >= cacheCanvas.getHeight();
- const shouldRefreshCache = isDirty || isForceDirty || isScrollJumpOutsideCache;
+ Math.abs(diffX) * scaleX >= cacheCanvas.getWidth() * cachePixelRatio ||
+ Math.abs(diffY) * scaleY >= cacheCanvas.getHeight() * cachePixelRatio;
+ const hasMergeData = spreadsheetSkeleton.worksheet.getMergeData().length > 0;
+ const isScrolling = diffX !== 0 || diffY !== 0;
+ const shouldRefreshCache = isDirty || isForceDirty || isScrollJumpOutsideCache || (hasMergeData && isScrolling) || (shouldCacheUpdate && diffX !== 0);
if (diffBounds.length === 0 || (diffX === 0 && diffY === 0) || shouldRefreshCache) {
if (shouldRefreshCache) {
this.addRenderTagToScene('scrolling', false);
@@ -386,6 +532,13 @@ export class Spreadsheet extends SheetComponent {
if (!spreadsheetSkeleton) {
return;
}
+
+ const { viewportKey } = viewportInfo;
+ if (sheetHeaderViewportKeys.includes(viewportKey as SHEET_VIEWPORT_KEY)) {
+ // Header viewports are rendered by row/column header components, not Spreadsheet.
+ return this;
+ }
+
spreadsheetSkeleton.setStylesCache(viewportInfo);
const segment = spreadsheetSkeleton.rowColumnSegment;
@@ -408,7 +561,6 @@ export class Spreadsheet extends SheetComponent {
this.getScene()?.updateTransformerZero(rowHeaderWidthAndMarginLeft, columnHeaderHeightAndMarginTop);
- const { viewportKey } = viewportInfo;
// scene --> layer, getObjects --> viewport.render(object) --> spreadsheet
// SHEET_COMPONENT_MAIN_LAYER_INDEX = 0;
// SHEET_COMPONENT_SELECTION_LAYER_INDEX = 1;
@@ -426,8 +578,6 @@ export class Spreadsheet extends SheetComponent {
} else {
this._draw(mainCtx, viewportInfo);
}
- } else if (sheetHeaderViewportKeys.includes(viewportKey as SHEET_VIEWPORT_KEY)) {
- // doing nothing, other components(SpreadsheetRowHeader...) will render
} else {
// embed in doc & slide
// now there are bugs in embed mode with cache on, 3f12ad80188a83283bcd95c65e6c5dcc2d23ad72
@@ -544,7 +694,7 @@ export class Spreadsheet extends SheetComponent {
* @param ctx
*/
// eslint-disable-next-line max-lines-per-function, complexity
- private _drawAuxiliary(ctx: UniverRenderingContext2D) {
+ private _drawAuxiliary(ctx: UniverRenderingContext2D, hasMergeData = true) {
const spreadsheetSkeleton = this.getSkeleton();
if (spreadsheetSkeleton == null) {
return;
@@ -606,25 +756,27 @@ export class Spreadsheet extends SheetComponent {
//#region draw horizontal lines
for (let r = rowStart; r <= rowEnd; r++) {
- if (worksheet.getRowVisible(r) === false) {
- if (mergeVisibleRangeStartRow < r) {
+ if (hasMergeData) {
+ if (worksheet.getRowVisible(r) === false) {
+ if (mergeVisibleRangeStartRow < r) {
+ mergeVisibleRanges.push({
+ startRow: mergeVisibleRangeStartRow,
+ endRow: r - 1,
+ startColumn,
+ endColumn,
+ });
+ mergeVisibleRangeStartRow = r + 1;
+ } else if (mergeVisibleRangeStartRow === r) {
+ mergeVisibleRangeStartRow = r + 1;
+ }
+ } else if (r === endRow && mergeVisibleRangeStartRow <= r) {
mergeVisibleRanges.push({
startRow: mergeVisibleRangeStartRow,
- endRow: r - 1,
+ endRow: r,
startColumn,
endColumn,
});
- mergeVisibleRangeStartRow = r + 1;
- } else if (mergeVisibleRangeStartRow === r) {
- mergeVisibleRangeStartRow = r + 1;
}
- } else if (r === endRow && mergeVisibleRangeStartRow <= r) {
- mergeVisibleRanges.push({
- startRow: mergeVisibleRangeStartRow,
- endRow: r,
- startColumn,
- endColumn,
- });
}
if (r < 0 || r > rowHeightAccumulationLength - 1) {
@@ -654,9 +806,11 @@ export class Spreadsheet extends SheetComponent {
// clear line of merge cell
const mergeCellRanges: IRange[] = [];
- for (const mergeVisibleRange of mergeVisibleRanges) {
- const mergeRangeInVisible = spreadsheetSkeleton.getCurrentRowColumnSegmentMergeData(mergeVisibleRange);
- mergeCellRanges.push(...mergeRangeInVisible);
+ if (hasMergeData) {
+ for (const mergeVisibleRange of mergeVisibleRanges) {
+ const mergeRangeInVisible = spreadsheetSkeleton.getCurrentRowColumnSegmentMergeData(mergeVisibleRange);
+ mergeCellRanges.push(...mergeRangeInVisible);
+ }
}
this._clearRectangle(ctx, rowHeightAccumulation, columnWidthAccumulation, mergeCellRanges);
diff --git a/packages/engine-render/src/shape/__tests__/scroll-bar.spec.ts b/packages/engine-render/src/shape/__tests__/scroll-bar.spec.ts
index 97b4b31c59..2ffae67c60 100644
--- a/packages/engine-render/src/shape/__tests__/scroll-bar.spec.ts
+++ b/packages/engine-render/src/shape/__tests__/scroll-bar.spec.ts
@@ -153,13 +153,83 @@ describe('ScrollBar', () => {
expect(scrollToBarPos).toHaveBeenCalledWith({ x: expect.any(Number) });
expect(scrollToBarPos).toHaveBeenCalledWith({ y: expect.any(Number) });
- expect(scrollByBarDeltaValue).toHaveBeenCalledWith({ x: 16 });
- expect(scrollByBarDeltaValue).toHaveBeenCalledWith({ y: 24 });
+ expect(scrollByBarDeltaValue).toHaveBeenCalledWith({ x: 16 }, true, { isBarDragEnd: true });
+ expect(scrollByBarDeltaValue).toHaveBeenCalledWith({ y: 24 }, true, { isBarDragEnd: true });
expect(setCapture).toHaveBeenCalled();
scrollBar.dispose();
});
+ it('coalesces rapid thumb drag deltas before scrolling the viewport', () => {
+ const scrollBar = new ScrollBar(viewport, { mainScene: scene });
+ const scrollByBarDeltaValue = vi.spyOn(viewport, 'scrollByBarDeltaValue');
+ const rafCallbacks: FrameRequestCallback[] = [];
+ vi.spyOn(window, 'requestAnimationFrame').mockImplementation((callback: FrameRequestCallback) => {
+ rafCallbacks.push(callback);
+ return rafCallbacks.length;
+ });
+ vi.spyOn(window, 'cancelAnimationFrame').mockImplementation(() => {});
+
+ scrollBar.resize(160, 120, 640, 480);
+ scrollBar.verticalThumbRect!.onPointerDown$.emitEvent({ offsetX: 154, offsetY: 24 } as any);
+ scene.onPointerMove$.emitEvent({ offsetX: 154, offsetY: 36 } as any);
+ scene.onPointerMove$.emitEvent({ offsetX: 154, offsetY: 48 } as any);
+
+ expect(scrollByBarDeltaValue).not.toHaveBeenCalled();
+ expect(rafCallbacks).toHaveLength(1);
+
+ rafCallbacks[0](16);
+
+ expect(scrollByBarDeltaValue).toHaveBeenCalledOnce();
+ expect(scrollByBarDeltaValue).toHaveBeenCalledWith({ y: 24 }, true, { isBarDragging: true });
+
+ scrollBar.dispose();
+ });
+
+ it('throttles continued thumb drag scrolling while preserving the latest delta', () => {
+ vi.useFakeTimers();
+ try {
+ const scrollBar = new ScrollBar(viewport, { mainScene: scene });
+ const scrollByBarDeltaValue = vi.spyOn(viewport, 'scrollByBarDeltaValue');
+ const rafCallbacks: FrameRequestCallback[] = [];
+ vi.spyOn(window, 'requestAnimationFrame').mockImplementation((callback: FrameRequestCallback) => {
+ rafCallbacks.push(callback);
+ return rafCallbacks.length;
+ });
+ vi.spyOn(window, 'cancelAnimationFrame').mockImplementation(() => {});
+
+ scrollBar.resize(160, 120, 640, 480);
+ scrollBar.verticalThumbRect!.onPointerDown$.emitEvent({ offsetX: 154, offsetY: 24 } as any);
+ scene.onPointerMove$.emitEvent({ offsetX: 154, offsetY: 36 } as any);
+ scene.onPointerMove$.emitEvent({ offsetX: 154, offsetY: 48 } as any);
+
+ rafCallbacks[0](16);
+ expect(scrollByBarDeltaValue).toHaveBeenCalledOnce();
+ expect(scrollByBarDeltaValue).toHaveBeenLastCalledWith({ y: 24 }, true, { isBarDragging: true });
+
+ scene.onPointerMove$.emitEvent({ offsetX: 154, offsetY: 60 } as any);
+ scene.onPointerMove$.emitEvent({ offsetX: 154, offsetY: 72 } as any);
+
+ expect(rafCallbacks).toHaveLength(1);
+ expect(scrollByBarDeltaValue).toHaveBeenCalledOnce();
+
+ vi.advanceTimersByTime(32);
+ expect(rafCallbacks).toHaveLength(2);
+
+ rafCallbacks[1](48);
+ expect(scrollByBarDeltaValue).toHaveBeenCalledTimes(2);
+ expect(scrollByBarDeltaValue).toHaveBeenLastCalledWith({ y: 24 }, true, { isBarDragging: true });
+
+ scene.onPointerUp$.emitEvent({ offsetX: 154, offsetY: 72 } as any);
+ expect(scrollByBarDeltaValue).toHaveBeenCalledTimes(3);
+ expect(scrollByBarDeltaValue).toHaveBeenLastCalledWith({ y: 0 }, true, { isBarDragEnd: true });
+
+ scrollBar.dispose();
+ } finally {
+ vi.useRealTimers();
+ }
+ });
+
it('supports single-axis scrollbars and no-op resize guards', () => {
const horizontalOnly = new ScrollBar(viewport, {
enableHorizontal: true,
diff --git a/packages/engine-render/src/shape/__tests__/text.spec.ts b/packages/engine-render/src/shape/__tests__/text.spec.ts
index 1bcec2837e..be4c6a657d 100644
--- a/packages/engine-render/src/shape/__tests__/text.spec.ts
+++ b/packages/engine-render/src/shape/__tests__/text.spec.ts
@@ -136,6 +136,63 @@ describe('text shape', () => {
expect(bottomCtx.beginPath).toHaveBeenCalled();
});
+ it('reuses simple text layouts for non-wrapped text', () => {
+ const cache = (Text as any)._layoutCache as Map<string, unknown>;
+ cache.clear();
+ const firstCtx = createCtx();
+ const secondCtx = createCtx();
+
+ Text.drawWith(
+ firstCtx,
+ {
+ text: 'repeat',
+ fontStyle: '12px Arial',
+ width: 100,
+ height: 20,
+ warp: false,
+ hAlign: HorizontalAlign.LEFT,
+ vAlign: VerticalAlign.TOP,
+ } as any
+ );
+ Text.drawWith(
+ secondCtx,
+ {
+ text: 'repeat',
+ fontStyle: '12px Arial',
+ width: 100,
+ height: 20,
+ warp: false,
+ hAlign: HorizontalAlign.LEFT,
+ vAlign: VerticalAlign.TOP,
+ } as any
+ );
+
+ expect(cache.size).toBe(1);
+ expect(firstCtx.fillText).toHaveBeenCalledTimes(1);
+ expect(secondCtx.fillText).toHaveBeenCalledTimes(1);
+ });
+
+ it('draws plain cached text without nested context save and restore', () => {
+ const ctx = createCtx();
+ const height = Text.drawPlainWith(
+ ctx,
+ {
+ text: '123',
+ fontStyle: '12px Arial',
+ width: 100,
+ height: 20,
+ hAlign: HorizontalAlign.RIGHT,
+ vAlign: VerticalAlign.TOP,
+ cellValueType: CellValueType.NUMBER,
+ } as any
+ );
+
+ expect(height).toBeGreaterThanOrEqual(0);
+ expect(ctx.save).not.toHaveBeenCalled();
+ expect(ctx.restore).not.toHaveBeenCalled();
+ expect(ctx.fillText.mock.calls[0][1]).toBeGreaterThanOrEqual(0);
+ });
+
it('draws underline and strike line decorations', () => {
const ctx = createCtx();
const skeleton = createSkeleton([{ text: 'abc', width: 6, height: 10, baseline: 8 }]);
diff --git a/packages/engine-render/src/shape/scroll-bar.ts b/packages/engine-render/src/shape/scroll-bar.ts
index 163e6d17d1..2ced170e85 100644
--- a/packages/engine-render/src/shape/scroll-bar.ts
+++ b/packages/engine-render/src/shape/scroll-bar.ts
@@ -59,6 +59,7 @@ const DEFAULT_TRACK_SIZE = 10;
const HOVER_TRACK_SIZE = 10;
const DEFAULT_THUMB_MARGIN = 2;
const HOVER_THUMB_MARGIN = 1;
+const BAR_DRAG_SCROLL_THROTTLE_MS = 32;
export class ScrollBar extends Disposable {
_enableHorizontal: boolean = true;
@@ -87,6 +88,11 @@ export class ScrollBar extends Disposable {
private _isHorizonMove = false;
private _isVerticalMove = false;
+ private _pendingBarDeltaX = 0;
+ private _pendingBarDeltaY = 0;
+ private _pendingBarScrollFrameId: number | null = null;
+ private _pendingBarScrollThrottleId: number | null = null;
+
private _horizonPointerMoveSub: Nullable<Subscription>;
private _horizonPointerUpSub: Nullable<Subscription>;
private _verticalPointerMoveSub: Nullable<Subscription>;
@@ -330,6 +336,7 @@ export class ScrollBar extends Disposable {
override dispose() {
super.dispose();
+ this._flushPendingBarScroll();
this.horizonScrollTrack?.dispose();
this.horizonThumbRect?.dispose();
this.verticalScrollTrack?.dispose();
@@ -351,6 +358,64 @@ export class ScrollBar extends Disposable {
this._viewport.removeScrollBar();
}
+ private _scheduleBarScrollDelta(delta: Partial<{ x: number; y: number }>) {
+ this._pendingBarDeltaX += delta.x ?? 0;
+ this._pendingBarDeltaY += delta.y ?? 0;
+
+ if (this._pendingBarScrollFrameId !== null || this._pendingBarScrollThrottleId !== null) {
+ return;
+ }
+
+ this._requestPendingBarScrollFrame();
+ }
+
+ private _requestPendingBarScrollFrame() {
+ this._pendingBarScrollFrameId = requestAnimationFrame(() => {
+ this._pendingBarScrollFrameId = null;
+ this._applyPendingBarScroll({ isBarDragging: true });
+
+ if (!this._isHorizonMove && !this._isVerticalMove) {
+ return;
+ }
+
+ this._pendingBarScrollThrottleId = window.setTimeout(() => {
+ this._pendingBarScrollThrottleId = null;
+ if (this._pendingBarDeltaX !== 0 || this._pendingBarDeltaY !== 0) {
+ this._requestPendingBarScrollFrame();
+ }
+ }, BAR_DRAG_SCROLL_THROTTLE_MS);
+ });
+ }
+
+ private _flushPendingBarScroll(isBarDragEnd = false) {
+ if (this._pendingBarScrollFrameId !== null) {
+ cancelAnimationFrame(this._pendingBarScrollFrameId);
+ this._pendingBarScrollFrameId = null;
+ }
+ if (this._pendingBarScrollThrottleId !== null) {
+ clearTimeout(this._pendingBarScrollThrottleId);
+ this._pendingBarScrollThrottleId = null;
+ }
+
+ return this._applyPendingBarScroll({ isBarDragEnd });
+ }
+
+ private _applyPendingBarScroll(options?: { isBarDragging?: boolean; isBarDragEnd?: boolean }) {
+ const x = this._pendingBarDeltaX;
+ const y = this._pendingBarDeltaY;
+ if (x === 0 && y === 0) {
+ return false;
+ }
+
+ this._pendingBarDeltaX = 0;
+ this._pendingBarDeltaY = 0;
+ this._viewport.scrollByBarDeltaValue({
+ ...(x === 0 ? null : { x }),
+ ...(y === 0 ? null : { y }),
+ }, true, options);
+ return true;
+ }
+
render(ctx: UniverRenderingContext, left: number = 0, top: number = 0) {
const { scrollX, scrollY } = this._viewport;
ctx.save();
@@ -642,7 +707,7 @@ export class ScrollBar extends Disposable {
if (!this._isVerticalMove) {
return;
}
- this._viewport.scrollByBarDeltaValue({
+ this._scheduleBarScrollDelta({
y: e.offsetY - this._lastY,
});
@@ -651,7 +716,14 @@ export class ScrollBar extends Disposable {
});
this._verticalPointerUpSub = mainScene.onPointerUp$.subscribeEvent((_evt: unknown, _state: EventState) => {
+ if (!this._isVerticalMove) {
+ return;
+ }
const srcElement = this.verticalThumbRect;
+ const hasPendingScroll = this._flushPendingBarScroll(true);
+ if (!hasPendingScroll) {
+ this._viewport.scrollByBarDeltaValue({ y: 0 }, true, { isBarDragEnd: true });
+ }
this._isVerticalMove = false;
mainScene.releaseCapturedObject();
mainScene.enableObjectsEvent();
@@ -755,7 +827,7 @@ export class ScrollBar extends Disposable {
if (!this._isHorizonMove) {
return;
}
- this._viewport.scrollByBarDeltaValue({
+ this._scheduleBarScrollDelta({
x: e.offsetX - this._lastX,
});
this._lastX = e.offsetX;
@@ -763,6 +835,13 @@ export class ScrollBar extends Disposable {
});
this._horizonPointerUpSub = mainScene.onPointerUp$.subscribeEvent((evt: unknown, state: EventState) => {
;
+ if (!this._isHorizonMove) {
+ return;
+ }
+ const hasPendingScroll = this._flushPendingBarScroll(true);
+ if (!hasPendingScroll) {
+ this._viewport.scrollByBarDeltaValue({ x: 0 }, true, { isBarDragEnd: true });
+ }
this._isHorizonMove = false;
mainScene.releaseCapturedObject();
mainScene.enableObjectsEvent();
diff --git a/packages/engine-render/src/shape/text.ts b/packages/engine-render/src/shape/text.ts
index 72d6a97792..0862f0edf1 100644
--- a/packages/engine-render/src/shape/text.ts
+++ b/packages/engine-render/src/shape/text.ts
@@ -40,6 +40,12 @@ export interface ITextProps extends IShapeProps {
export const TEXT_OBJECT_ARRAY = ['text', 'fontStyle', 'warp', 'hAlign', 'vAlign', 'width', 'height', 'color'];
export class Text extends Shape<ITextProps> {
+ private static readonly _MAX_LAYOUT_CACHE_SIZE = 5000;
+ private static readonly _layoutCache = new Map<string, {
+ lines: ReturnType<DocSimpleSkeleton['calculate']>;
+ totalHeight: number;
+ }>();
+
text: string;
fontStyle: string;
warp: boolean;
@@ -68,9 +74,10 @@ export class Text extends Shape<ITextProps> {
static override drawWith(ctx: UniverRenderingContext, props: ITextProps, _skeleton?: DocSimpleSkeleton) {
const { text, fontStyle, warp, hAlign, vAlign, width, height, left = 0, top = 0, cellValueType } = props;
- const skeleton = _skeleton ?? new DocSimpleSkeleton(text, fontStyle, Boolean(warp), width, vAlign === VerticalAlign.TOP ? height : Infinity);
- const lines = skeleton.calculate();
- const totalHeight = skeleton.getTotalHeight();
+ const cachedLayout = !_skeleton && !warp ? Text._getCachedLayout(text, fontStyle) : null;
+ const skeleton = cachedLayout ? null : _skeleton ?? new DocSimpleSkeleton(text, fontStyle, Boolean(warp), width, vAlign === VerticalAlign.TOP ? height : Infinity);
+ const lines = cachedLayout?.lines ?? skeleton!.calculate();
+ const totalHeight = cachedLayout?.totalHeight ?? skeleton!.getTotalHeight();
const offsetY = vAlign === VerticalAlign.TOP ? 0 : vAlign === VerticalAlign.MIDDLE ? (height - totalHeight) / 2 : height - totalHeight;
let lineTop = top + offsetY;
@@ -142,6 +149,63 @@ export class Text extends Shape<ITextProps> {
return totalHeight;
}
+ static drawPlainWith(ctx: UniverRenderingContext, props: ITextProps) {
+ const { text, fontStyle, hAlign, vAlign, width, height, left = 0, top = 0, cellValueType } = props;
+ const cachedLayout = Text._getCachedLayout(text, fontStyle);
+ const { lines, totalHeight } = cachedLayout;
+ const offsetY = vAlign === VerticalAlign.TOP ? 0 : vAlign === VerticalAlign.MIDDLE ? (height - totalHeight) / 2 : height - totalHeight;
+ let lineTop = top + offsetY;
+
+ ctx.font = fontStyle;
+ ctx.fillStyle = props.color ?? COLOR_BLACK_RGB;
+
+ for (const line of lines) {
+ const lineWidth = line.width;
+ let lineX = 0;
+ if (!(width < lineWidth && cellValueType === CellValueType.NUMBER)) {
+ switch (hAlign) {
+ case HorizontalAlign.CENTER:
+ lineX = (width - lineWidth) / 2;
+ break;
+ case HorizontalAlign.RIGHT:
+ lineX = width - lineWidth;
+ break;
+ default:
+ lineX = 0;
+ }
+ }
+
+ ctx.fillText(line.text, left + lineX, lineTop + line.baseline);
+ lineTop += line.height;
+ }
+
+ return totalHeight;
+ }
+
+ private static _getCachedLayout(text: string, fontStyle: string) {
+ const cacheKey = `${fontStyle}\u0000${text}`;
+ const cached = Text._layoutCache.get(cacheKey);
+ if (cached) {
+ return cached;
+ }
+
+ const skeleton = new DocSimpleSkeleton(text, fontStyle, false, 0, Infinity);
+ const layout = {
+ lines: skeleton.calculate(),
+ totalHeight: skeleton.getTotalHeight(),
+ };
+
+ Text._layoutCache.set(cacheKey, layout);
+ if (Text._layoutCache.size > Text._MAX_LAYOUT_CACHE_SIZE) {
+ const oldestKey = Text._layoutCache.keys().next().value;
+ if (oldestKey !== undefined) {
+ Text._layoutCache.delete(oldestKey);
+ }
+ }
+
+ return layout;
+ }
+
/**
* Draw text decoration lines (underline, strikethrough, etc.)
*/
diff --git a/packages/engine-render/src/viewport.ts b/packages/engine-render/src/viewport.ts
index 84f28cf868..391fc2d12d 100644
--- a/packages/engine-render/src/viewport.ts
+++ b/packages/engine-render/src/viewport.ts
@@ -83,6 +83,13 @@ export interface IScrollObserverParam {
limitX?: number;
limitY?: number;
isTrigger?: boolean;
+ isBarDragging?: boolean;
+ isBarDragEnd?: boolean;
+}
+
+interface IScrollByBarOptions {
+ isBarDragging?: boolean;
+ isBarDragEnd?: boolean;
}
interface IScrollBarPosition {
@@ -549,10 +556,10 @@ export class Viewport {
* @param delta
* @returns isLimited
*/
- scrollByBarDeltaValue(delta: Partial<IScrollBarPosition>, isTrigger = true) {
+ scrollByBarDeltaValue(delta: Partial<IScrollBarPosition>, isTrigger = true, options?: IScrollByBarOptions) {
const x = this.scrollX + (delta.x || 0);
const y = this.scrollY + (delta.y || 0);
- return this._scrollToBarPosCore({ x, y }, isTrigger);
+ return this._scrollToBarPosCore({ x, y }, isTrigger, options);
}
/**
@@ -1286,7 +1293,7 @@ export class Viewport {
* @param rawScrollXY Partial<IViewportScrollPosition>
* @param isTrigger
*/
- private _scrollToBarPosCore(rawScrollXY: Partial<IScrollBarPosition>, isTrigger: boolean = true) {
+ private _scrollToBarPosCore(rawScrollXY: Partial<IScrollBarPosition>, isTrigger: boolean = true, options?: IScrollByBarOptions) {
if (this._scrollBar == null) {
return;
}
@@ -1314,6 +1321,8 @@ export class Viewport {
limitX: this._scrollBar?.limitX,
limitY: this._scrollBar?.limitY,
isTrigger,
+ isBarDragging: options?.isBarDragging,
+ isBarDragEnd: options?.isBarDragEnd,
};
this._scrollBar?.makeDirty(true);
this.onScrollAfter$.emitEvent(scrollSubParam);
@@ -1329,6 +1338,8 @@ export class Viewport {
limitX: this._scrollBar?.limitX,
limitY: this._scrollBar?.limitY,
isTrigger,
+ isBarDragging: options?.isBarDragging,
+ isBarDragEnd: options?.isBarDragEnd,
});
return afterLimit;
}
@@ -1518,13 +1529,11 @@ export class Viewport {
right: Math.min(prevBound.right, currBound.right),
});
}
- const expandX = this.bufferEdgeX;
- const expandY = this.bufferEdgeY;
for (const bound of additionalAreas) {
- bound.left = bound.left - expandX;
- bound.right = bound.right + expandX;
- bound.top = bound.top - expandY;
- bound.bottom = bound.bottom + expandY;
+ bound.left = bound.left - this.bufferEdgeX;
+ bound.right = bound.right + this.bufferEdgeX;
+ bound.top = bound.top - this.bufferEdgeY;
+ bound.bottom = bound.bottom + this.bufferEdgeY;
}
return additionalAreas;
diff --git a/packages/sheets-conditional-formatting-ui/src/controllers/__tests__/cf.render.controller.spec.ts b/packages/sheets-conditional-formatting-ui/src/controllers/__tests__/cf.render.controller.spec.ts
index ae26effe89..78efd1ac96 100644
--- a/packages/sheets-conditional-formatting-ui/src/controllers/__tests__/cf.render.controller.spec.ts
+++ b/packages/sheets-conditional-formatting-ui/src/controllers/__tests__/cf.render.controller.spec.ts
@@ -14,6 +14,7 @@
* limitations under the License.
*/
+import type { IRange } from '@univerjs/core';
import { INTERCEPTOR_POINT } from '@univerjs/sheets';
import { DEFAULT_PADDING, DEFAULT_WIDTH } from '@univerjs/sheets-conditional-formatting';
import { Subject } from 'rxjs';
@@ -24,12 +25,22 @@ afterEach(() => {
vi.useRealTimers();
});
+interface ITestConditionFormattingRule {
+ ranges: IRange[];
+}
+
function createController() {
let interceptor: any;
const ruleChange$ = new Subject<any>();
const markDirty$ = new Subject<any>();
const reCalculate = vi.fn();
const makeDirty = vi.fn();
+ const resetRangeCache = vi.fn();
+ const rowColumnSegment = { startRow: 0, endRow: 10, startColumn: 0, endColumn: 10 };
+ const getRule = vi.fn<() => ITestConditionFormattingRule>(() => ({
+ ranges: [{ startRow: 2, endRow: 4, startColumn: 1, endColumn: 3 }],
+ }));
+ const getSubunitRules = vi.fn<() => ITestConditionFormattingRule[]>(() => []);
const controller = new SheetsCfRenderController(
{
intercept: vi.fn((point, config) => {
@@ -54,15 +65,15 @@ function createController() {
} as never,
{
getRenderById: vi.fn(() => ({
- with: vi.fn(() => ({ reCalculate })),
+ with: vi.fn(() => ({ getCurrentSkeleton: vi.fn(() => ({ resetRangeCache, rowColumnSegment })), reCalculate })),
mainComponent: { makeDirty },
})),
} as never,
{ markDirty$ } as never,
- { $ruleChange: ruleChange$ } as never
+ { $ruleChange: ruleChange$, getRule, getSubunitRules } as never
);
- return { controller, interceptor: () => interceptor, ruleChange$, markDirty$, reCalculate, makeDirty };
+ return { controller, getRule, getSubunitRules, interceptor: () => interceptor, markDirty$, makeDirty, reCalculate, resetRangeCache, rowColumnSegment, ruleChange$ };
}
describe('SheetsCfRenderController', () => {
@@ -97,15 +108,58 @@ describe('SheetsCfRenderController', () => {
it('marks the active sheet skeleton dirty when conditional formatting changes affect it', async () => {
vi.useFakeTimers();
- const { controller, ruleChange$, markDirty$, reCalculate, makeDirty } = createController();
+ const { controller, ruleChange$, markDirty$, reCalculate, makeDirty, resetRangeCache } = createController();
- ruleChange$.next({ unitId: 'unit-1', subUnitId: 'sheet-1' });
+ const ranges = [{ startRow: 0, endRow: 1, startColumn: 0, endColumn: 1 }];
+ ruleChange$.next({ unitId: 'unit-1', subUnitId: 'sheet-1', rule: { ranges } });
markDirty$.next({ unitId: 'other-unit', subUnitId: 'sheet-1' });
await vi.advanceTimersByTimeAsync(20);
+ expect(resetRangeCache).toHaveBeenCalledWith(ranges);
expect(reCalculate).toHaveBeenCalled();
expect(makeDirty).toHaveBeenCalled();
controller.dispose();
});
+
+ it('resets changed ranges found from conditional-formatting dirty cfIds', async () => {
+ vi.useFakeTimers();
+ const { controller, getRule, markDirty$, resetRangeCache, rowColumnSegment } = createController();
+
+ markDirty$.next({ unitId: 'unit-1', subUnitId: 'sheet-1', cfId: 'cf-1' });
+ await vi.advanceTimersByTimeAsync(20);
+
+ expect(getRule).toHaveBeenCalledWith('unit-1', 'sheet-1', 'cf-1');
+ expect(resetRangeCache).toHaveBeenCalledWith([{ startRow: 2, endRow: 4, startColumn: 1, endColumn: 3 }]);
+
+ controller.dispose();
+ });
+
+ it('resets existing active-sheet rule ranges when the controller starts after snapshot rules are loaded', async () => {
+ const { controller, getSubunitRules, resetRangeCache } = createController();
+ const ranges = [{ startRow: 5, endRow: 6, startColumn: 2, endColumn: 4 }];
+ getSubunitRules.mockReturnValue([{ ranges }]);
+
+ await Promise.resolve();
+
+ expect(getSubunitRules).toHaveBeenCalledWith('unit-1', 'sheet-1');
+ expect(resetRangeCache).toHaveBeenCalledWith(ranges);
+
+ controller.dispose();
+ });
+
+ it('clips large conditional-formatting dirty ranges to the current rendered range', async () => {
+ vi.useFakeTimers();
+ const { controller, getRule, markDirty$, resetRangeCache, rowColumnSegment } = createController();
+ getRule.mockReturnValue({
+ ranges: [{ startRow: 0, endRow: 20000, startColumn: 0, endColumn: 48 }],
+ });
+
+ markDirty$.next({ unitId: 'unit-1', subUnitId: 'sheet-1', cfId: 'cf-1' });
+ await vi.advanceTimersByTimeAsync(20);
+
+ expect(resetRangeCache).toHaveBeenCalledWith([rowColumnSegment]);
+
+ controller.dispose();
+ });
});
diff --git a/packages/sheets-conditional-formatting-ui/src/controllers/cf.render.controller.ts b/packages/sheets-conditional-formatting-ui/src/controllers/cf.render.controller.ts
index 81a1503fec..5cc9d1d55c 100644
--- a/packages/sheets-conditional-formatting-ui/src/controllers/cf.render.controller.ts
+++ b/packages/sheets-conditional-formatting-ui/src/controllers/cf.render.controller.ts
@@ -14,7 +14,7 @@
* limitations under the License.
*/
-import type { ICellDataForSheetInterceptor, Workbook } from '@univerjs/core';
+import type { ICellDataForSheetInterceptor, IRange, Workbook } from '@univerjs/core';
import type { IConditionalFormattingCellData, IConditionFormattingRule } from '@univerjs/sheets-conditional-formatting';
import { Disposable, Inject, InterceptorEffectEnum, IUniverInstanceService, UniverInstanceType } from '@univerjs/core';
import { IRenderManagerService } from '@univerjs/engine-render';
@@ -49,15 +49,82 @@ export class SheetsCfRenderController extends Disposable {
this._initViewModelInterceptor();
this._initSkeleton();
+ queueMicrotask(() => this._markActiveSheetRulesDirty());
this.disposeWithMe(() => {
this._ruleChangeCacheMap.clear();
});
}
- private _markDirtySkeleton() {
- const unitId = this._univerInstanceService.getCurrentUnitOfType<Workbook>(UniverInstanceType.UNIVER_SHEET)!.getUnitId();
- this._renderManagerService.getRenderById(unitId)?.with(SheetSkeletonManagerService).reCalculate();
- this._renderManagerService.getRenderById(unitId)?.mainComponent?.makeDirty();
+ private _collectDirtyRanges(items: Array<{ cfId?: string; rule?: IConditionFormattingRule; subUnitId: string; unitId: string }>, unitId: string, subUnitId: string): IRange[] {
+ const ranges: IRange[] = [];
+
+ items.forEach((item) => {
+ if (item.unitId !== unitId || item.subUnitId !== subUnitId) {
+ return;
+ }
+
+ const rule = item.rule ?? (item.cfId ? this._conditionalFormattingRuleModel.getRule(unitId, subUnitId, item.cfId) : null);
+ if (rule?.ranges?.length) {
+ ranges.push(...rule.ranges);
+ }
+ });
+
+ return ranges;
+ }
+
+ private _intersectDirtyRangesWithRenderedRange(ranges: IRange[], renderedRange?: IRange): IRange[] {
+ if (!renderedRange || renderedRange.startRow < 0 || renderedRange.startColumn < 0) {
+ return [];
+ }
+
+ return ranges.map((range) => ({
+ startRow: Math.max(range.startRow, renderedRange.startRow),
+ endRow: Math.min(range.endRow, renderedRange.endRow),
+ startColumn: Math.max(range.startColumn, renderedRange.startColumn),
+ endColumn: Math.min(range.endColumn, renderedRange.endColumn),
+ })).filter((range) => range.startRow <= range.endRow && range.startColumn <= range.endColumn);
+ }
+
+ private _markDirtySkeleton(items: Array<{ cfId?: string; rule?: IConditionFormattingRule; subUnitId: string; unitId: string }>) {
+ const workbook = this._univerInstanceService.getCurrentUnitOfType<Workbook>(UniverInstanceType.UNIVER_SHEET);
+ const worksheet = workbook?.getActiveSheet();
+ if (!workbook || !worksheet) {
+ return;
+ }
+
+ const unitId = workbook.getUnitId();
+ const subUnitId = worksheet.getSheetId();
+ const render = this._renderManagerService.getRenderById(unitId);
+ const skeletonManagerService = render?.with(SheetSkeletonManagerService);
+ const currentSkeleton = skeletonManagerService?.getCurrentSkeleton();
+ const dirtyRanges = this._intersectDirtyRangesWithRenderedRange(
+ this._collectDirtyRanges(items, unitId, subUnitId),
+ currentSkeleton?.rowColumnSegment
+ );
+
+ if (dirtyRanges.length) {
+ currentSkeleton?.resetRangeCache(dirtyRanges);
+ }
+
+ skeletonManagerService?.reCalculate();
+ render?.mainComponent?.makeDirty();
+ }
+
+ private _markActiveSheetRulesDirty() {
+ const workbook = this._univerInstanceService.getCurrentUnitOfType<Workbook>(UniverInstanceType.UNIVER_SHEET);
+ const worksheet = workbook?.getActiveSheet();
+ if (!workbook || !worksheet) {
+ return;
+ }
+
+ const unitId = workbook.getUnitId();
+ const subUnitId = worksheet.getSheetId();
+ const rules = this._conditionalFormattingRuleModel.getSubunitRules(unitId, subUnitId) ?? [];
+ if (!rules.length) {
+ return;
+ }
+
+ this._markDirtySkeleton(rules.map((rule) => ({ rule, subUnitId, unitId })));
}
private _initSkeleton() {
@@ -74,7 +141,7 @@ export class SheetsCfRenderController extends Disposable {
return v.some((item) => item.unitId === workbook.getUnitId() && item.subUnitId === worksheet.getSheetId());
})
- ).subscribe(() => this._markDirtySkeleton()));
+ ).subscribe((items) => this._markDirtySkeleton(items)));
}
private _initViewModelInterceptor() {
diff --git a/packages/sheets-ui/src/controllers/render-controllers/__tests__/scroll.render-controller.spec.ts b/packages/sheets-ui/src/controllers/render-controllers/__tests__/scroll.render-controller.spec.ts
index bd2da02d21..18ce292222 100644
--- a/packages/sheets-ui/src/controllers/render-controllers/__tests__/scroll.render-controller.spec.ts
+++ b/packages/sheets-ui/src/controllers/render-controllers/__tests__/scroll.render-controller.spec.ts
@@ -140,6 +140,8 @@ describe('SheetsScrollRenderController', () => {
expect(viewMain.limitedScroll).toHaveBeenCalledWith(0, 2);
expect(preventDefault).toHaveBeenCalled();
+ expect(viewMain.scrollY).toBe(-34);
+ expect(viewMain.viewportScrollY).toBe(20);
void controller;
});
@@ -233,6 +235,44 @@ describe('SheetsScrollRenderController', () => {
void controller;
});
+ it('defers ScrollCommand for intermediate scrollbar drag events until drag end', () => {
+ const scrollManagerService = createScrollManagerServiceMock();
+ const testBed = createRenderTestBed({
+ dependencies: [[SheetScrollManagerService, { useValue: scrollManagerService }]],
+ });
+ const { context, viewportMap } = testBed;
+ const commandService = testBed.get(ICommandService);
+ const executeSpy = vi.spyOn(commandService, 'executeCommand');
+
+ const controller = testBed.injector.createInstance(SheetsScrollRenderController, context as any);
+ const viewMain = viewportMap.get(SHEET_VIEWPORT_KEY.VIEW_MAIN) as any;
+
+ viewMain.onScrollByBar$.emit({
+ isTrigger: true,
+ isBarDragging: true,
+ viewportScrollX: 250,
+ viewportScrollY: 45,
+ }, {});
+
+ expect(executeSpy).not.toHaveBeenCalledWith(ScrollCommand.id, expect.anything());
+
+ viewMain.onScrollByBar$.emit({
+ isTrigger: true,
+ isBarDragEnd: true,
+ viewportScrollX: 250,
+ viewportScrollY: 45,
+ }, {});
+
+ expect(executeSpy).toHaveBeenCalledWith(ScrollCommand.id, {
+ sheetViewStartRow: 2,
+ sheetViewStartColumn: 2,
+ offsetX: 50,
+ offsetY: 5,
+ });
+
+ void controller;
+ });
+
it('handles skeleton switch sync and raw scroll updates', () => {
const scrollManagerService = createScrollManagerServiceMock();
(scrollManagerService as any).getScrollStateByParam = vi.fn(() => ({
diff --git a/packages/sheets-ui/src/controllers/render-controllers/mobile/mobile-scroll.render-controller.ts b/packages/sheets-ui/src/controllers/render-controllers/mobile/mobile-scroll.render-controller.ts
index c4bba0b6ac..22c05d4af0 100644
--- a/packages/sheets-ui/src/controllers/render-controllers/mobile/mobile-scroll.render-controller.ts
+++ b/packages/sheets-ui/src/controllers/render-controllers/mobile/mobile-scroll.render-controller.ts
@@ -253,7 +253,7 @@ export class MobileSheetsScrollRenderController extends Disposable implements IR
this.disposeWithMe(
viewportMain.onScrollByBar$.subscribeEvent((param) => {
const skeleton = this._sheetSkeletonManagerService.getCurrentParam()?.skeleton;
- if (skeleton == null || param.isTrigger === false) {
+ if (skeleton == null || param.isTrigger === false || (param.isBarDragging && !param.isBarDragEnd)) {
return;
}
diff --git a/packages/sheets-ui/src/controllers/render-controllers/scroll.render-controller.ts b/packages/sheets-ui/src/controllers/render-controllers/scroll.render-controller.ts
index 792033a51c..bcab5aa839 100644
--- a/packages/sheets-ui/src/controllers/render-controllers/scroll.render-controller.ts
+++ b/packages/sheets-ui/src/controllers/render-controllers/scroll.render-controller.ts
@@ -235,7 +235,7 @@ export class SheetsScrollRenderController extends Disposable implements IRenderM
// get scrollByBar event from viewport and exec ScrollCommand.id.
viewportMain.onScrollByBar$.subscribeEvent((param) => {
const skeleton = this._sheetSkeletonManagerService.getCurrentParam()?.skeleton;
- if (skeleton == null || param.isTrigger === false) {
+ if (skeleton == null || param.isTrigger === false || (param.isBarDragging && !param.isBarDragEnd)) {
return;
}