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(sheets): optimize render caching and mobile scrolling (#8125)

Univerbd926a892e8f
diff --git a/packages/core/src/common/__tests__/interceptor.spec.ts b/packages/core/src/common/__tests__/interceptor.spec.ts
index 99a89040c7..97347f8abd 100644
--- a/packages/core/src/common/__tests__/interceptor.spec.ts
+++ b/packages/core/src/common/__tests__/interceptor.spec.ts
@@ -14,13 +14,32 @@
* limitations under the License.
*/
-import { describe, expect, it } from 'vitest';
-import { AsyncInterceptorManager, createAsyncInterceptorKey } from '../interceptor';
+import { Injector } from '@wendellhu/redi';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { AsyncInterceptorManager, createAsyncInterceptorKey, createInterceptorKey, InterceptorManager } from '../interceptor';
+
+let injector: Injector;
+beforeEach(() => {
+ injector = new Injector();
+});
+afterEach(() => injector.dispose());
+
+function createManager<P extends ConstructorParameters<typeof InterceptorManager>[0]>(points: P) {
+ const Manager = InterceptorManager<P>;
+ injector.add([Manager, { useFactory: () => injector.createInstance(Manager, points) }]);
+ return injector.get(Manager);
+}
+
+function createAsyncManager<P extends ConstructorParameters<typeof AsyncInterceptorManager>[0]>(points: P) {
+ const Manager = AsyncInterceptorManager<P>;
+ injector.add([Manager, { useFactory: () => injector.createInstance(Manager, points) }]);
+ return injector.get(Manager);
+}
describe('Test interceptor', () => {
it('should return "true" when each interceptor returns true ', async () => {
const INTERCEPTOR_KEY = createAsyncInterceptorKey<boolean, boolean>('test');
- const interceptor = new AsyncInterceptorManager({ INTERCEPTOR_KEY });
+ const interceptor = createAsyncManager({ INTERCEPTOR_KEY });
interceptor.interceptAsync(interceptor.getInterceptPoints().INTERCEPTOR_KEY, {
priority: 0,
@@ -42,7 +61,7 @@ describe('Test interceptor', () => {
it('should return "false" when one of the interceptor returns false', async () => {
const INTERCEPTOR_KEY = createAsyncInterceptorKey<boolean, boolean>('test');
- const interceptor = new AsyncInterceptorManager({ INTERCEPTOR_KEY });
+ const interceptor = createAsyncManager({ INTERCEPTOR_KEY });
interceptor.interceptAsync(interceptor.getInterceptPoints().INTERCEPTOR_KEY, {
priority: 0,
@@ -62,3 +81,313 @@ describe('Test interceptor', () => {
expect(interceptorRes).toBe(false);
});
});
+
+describe('interceptor subscription cleanup', () => {
+ it('can release a synchronous registration after its manager is disposed', () => {
+ const key = createInterceptorKey<boolean, boolean>('late-cleanup');
+ const manager = createManager({ key });
+ const handler = { handler: () => true };
+ const release = manager.intercept(key, handler);
+ manager.dispose();
+ expect(release()).toBe(false);
+ expect(release()).toBe(false);
+ });
+
+ it('can release an asynchronous registration after its manager is disposed', async () => {
+ const key = createAsyncInterceptorKey<boolean, boolean>('late-cleanup');
+ const manager = createAsyncManager({ key });
+ const handler = { handler: async () => true };
+ const release = await manager.interceptAsync(key, handler);
+ manager.dispose();
+ expect(release()).toBe(false);
+ expect(release()).toBe(false);
+ });
+});
+
+describe('synchronous interceptor lifecycle', () => {
+ it('preserves priority, context, filtering and cached chains when unregistering', () => {
+ const key = createInterceptorKey<number, number>('chain');
+ const manager = createManager({ key });
+ const calls: string[] = [];
+ manager.intercept(key, {
+ priority: 0,
+ handler: (value, context, next) => {
+ calls.push('last');
+ return next(value! + context);
+ },
+ });
+ const release = manager.intercept(key, {
+ priority: 5,
+ handler: (value, _context, next) => {
+ calls.push('middle');
+ return next(value! * 2);
+ },
+ });
+ manager.intercept(key, {
+ priority: 10,
+ handler: (value, context, next) => {
+ calls.push('first');
+ return next(value! + context);
+ },
+ });
+ const chain = manager.fetchThroughInterceptors(key);
+ const filtered = manager.fetchThroughInterceptors(key, (entry) => entry.priority! >= 5);
+ expect(chain(1, 2)).toBe(8);
+ expect(calls).toEqual(['first', 'middle', 'last']);
+ expect(filtered(1, 2)).toBe(6);
+ expect(release()).toBe(true);
+ expect(chain(1, 2)).toBe(5);
+ expect(filtered(1, 2)).toBe(6);
+ });
+
+ it('preserves short circuiting and propagates handler errors', () => {
+ const key = createInterceptorKey<boolean, null>('validation');
+ const manager = createManager({ key });
+ const tail = vi.fn(() => true);
+ manager.intercept(key, { priority: 0, handler: tail });
+ const release = manager.intercept(key, { priority: 10, handler: () => false });
+ expect(manager.fetchThroughInterceptors(key)(true, null)).toBe(false);
+ expect(tail).not.toHaveBeenCalled();
+ release();
+ expect(manager.fetchThroughInterceptors(key)(false, null)).toBe(true);
+ const error = new Error('validation failed');
+ manager.intercept(key, {
+ priority: 20,
+ handler: () => {
+ throw error;
+ },
+ });
+ expect(() => manager.fetchThroughInterceptors(key)(true, null)).toThrow(error);
+ });
+
+ it('does not remove another registration when an old callback is called twice', () => {
+ const key = createInterceptorKey<boolean, null>('repeated-release');
+ const manager = createManager({ key });
+ const handler = { handler: () => true };
+ const release = manager.intercept(key, handler);
+ const releaseOther = manager.intercept(key, handler);
+ expect(release()).toBe(true);
+ expect(release()).toBe(false);
+ expect(manager.fetchThroughInterceptors(key)(false, null)).toBe(true);
+ expect(releaseOther()).toBe(true);
+ expect(manager.fetchThroughInterceptors(key)(false, null)).toBe(false);
+ });
+
+ it('rejects registration and chain creation after terminal disposal', () => {
+ const key = createInterceptorKey<boolean, null>('terminal');
+ const manager = createManager({ key });
+ const handler = { handler: () => true };
+ const release = manager.intercept(key, handler);
+ manager.dispose();
+ expect(() => manager.dispose()).not.toThrow();
+ expect(() => manager.intercept(key, handler)).toThrow(/disposed/);
+ expect(() => manager.fetchThroughInterceptors(key)).toThrow(/disposed/);
+ const filter = vi.fn(() => true);
+ expect(() => manager.fetchThroughInterceptors(key, filter)).toThrow(/disposed/);
+ expect(filter).not.toHaveBeenCalled();
+ expect(release()).toBe(false);
+ expect(release()).toBe(false);
+ });
+
+ it('only unregisters from the requested interception point', () => {
+ const first = createInterceptorKey<boolean, null>('first');
+ const second = createInterceptorKey<boolean, null>('second');
+ const manager = createManager({ first, second });
+ const handler = { handler: () => true };
+ const release = manager.intercept(first, handler);
+ manager.intercept(second, handler);
+ release();
+ expect(manager.fetchThroughInterceptors(first)(false, null)).toBe(false);
+ expect(manager.fetchThroughInterceptors(second)(false, null)).toBe(true);
+ });
+
+ it('rejects later invocations of cached and filtered chains after disposal', () => {
+ const key = createInterceptorKey<boolean, null>('cached-chain');
+ const manager = createManager({ key });
+ const handler = vi.fn(() => true);
+ manager.intercept(key, { handler });
+ const chain = manager.fetchThroughInterceptors(key);
+ const filtered = manager.fetchThroughInterceptors(key, () => true);
+ manager.dispose();
+ expect(() => chain(false, null)).toThrow(/disposed/);
+ expect(() => filtered(false, null)).toThrow(/disposed/);
+ expect(handler).not.toHaveBeenCalled();
+ });
+
+ it('remains terminal when an owned cleanup throws', () => {
+ const key = createInterceptorKey<boolean, null>('cleanup-error');
+ const manager = createManager({ key });
+ const release = manager.intercept(key, { handler: () => true });
+ const error = new Error('cleanup failed');
+ manager.disposeWithMe(() => {
+ throw error;
+ });
+ expect(() => manager.dispose()).toThrow(error);
+ expect(() => manager.intercept(key, { handler: () => true })).toThrow(/disposed/);
+ expect(release()).toBe(false);
+ expect(() => manager.dispose()).not.toThrow();
+ });
+
+ it('lets a running chain finish when a handler disposes the manager', () => {
+ const key = createInterceptorKey<number, null>('in-flight');
+ const manager = createManager({ key });
+ manager.intercept(key, {
+ priority: 10,
+ handler: (value, _context, next) => {
+ manager.dispose();
+ return next(value! + 1);
+ },
+ });
+ manager.intercept(key, { handler: (value, _context, next) => next(value! * 2) });
+ expect(manager.fetchThroughInterceptors(key)(1, null)).toBe(4);
+ expect(() => manager.fetchThroughInterceptors(key)).toThrow(/disposed/);
+ });
+});
+
+describe('asynchronous interceptor lifecycle', () => {
+ it('preserves priority, context, filtering and cached chains when unregistering', async () => {
+ const key = createAsyncInterceptorKey<number, number>('chain');
+ const manager = createAsyncManager({ key });
+ const calls: string[] = [];
+ await manager.interceptAsync(key, {
+ priority: 0,
+ handler: async (value, context, next) => {
+ calls.push('last');
+ return next(value! + context);
+ },
+ });
+ const release = await manager.interceptAsync(key, {
+ priority: 5,
+ handler: async (value, _context, next) => {
+ calls.push('middle');
+ return next(value! * 2);
+ },
+ });
+ await manager.interceptAsync(key, {
+ priority: 10,
+ handler: async (value, context, next) => {
+ calls.push('first');
+ return next(value! + context);
+ },
+ });
+ const chain = manager.fetchThroughAsyncInterceptors(key);
+ const filtered = manager.fetchThroughAsyncInterceptors(key, (entry) => entry.priority! >= 5);
+ expect(await chain(1, 2)).toBe(8);
+ expect(calls).toEqual(['first', 'middle', 'last']);
+ expect(await filtered(1, 2)).toBe(6);
+ expect(release()).toBe(true);
+ expect(await chain(1, 2)).toBe(5);
+ expect(await filtered(1, 2)).toBe(6);
+ });
+
+ it('preserves short circuiting and propagates handler errors', async () => {
+ const key = createAsyncInterceptorKey<boolean, null>('validation');
+ const manager = createAsyncManager({ key });
+ const tail = vi.fn(async () => true);
+ await manager.interceptAsync(key, { priority: 0, handler: tail });
+ const release = await manager.interceptAsync(key, { priority: 10, handler: async () => false });
+ expect(await manager.fetchThroughAsyncInterceptors(key)(true, null)).toBe(false);
+ expect(tail).not.toHaveBeenCalled();
+ release();
+ expect(await manager.fetchThroughAsyncInterceptors(key)(false, null)).toBe(true);
+ const error = new Error('validation failed');
+ await manager.interceptAsync(key, {
+ priority: 20,
+ handler: async () => {
+ throw error;
+ },
+ });
+ await expect(manager.fetchThroughAsyncInterceptors(key)(true, null)).rejects.toThrow(error);
+ });
+
+ it('does not remove another registration when an old callback is called twice', async () => {
+ const key = createAsyncInterceptorKey<boolean, null>('repeated-release');
+ const manager = createAsyncManager({ key });
+ const handler = { handler: async () => true };
+ const release = await manager.interceptAsync(key, handler);
+ const releaseOther = await manager.interceptAsync(key, handler);
+ expect(release()).toBe(true);
+ expect(release()).toBe(false);
+ expect(await manager.fetchThroughAsyncInterceptors(key)(false, null)).toBe(true);
+ expect(releaseOther()).toBe(true);
+ expect(await manager.fetchThroughAsyncInterceptors(key)(false, null)).toBe(false);
+ });
+
+ it('rejects registration and chain creation after terminal disposal', async () => {
+ const key = createAsyncInterceptorKey<boolean, null>('terminal');
+ const manager = createAsyncManager({ key });
+ const handler = { handler: async () => true };
+ const release = await manager.interceptAsync(key, handler);
+ manager.dispose();
+ expect(() => manager.dispose()).not.toThrow();
+ await expect(manager.interceptAsync(key, handler)).rejects.toThrow(/disposed/);
+ expect(() => manager.fetchThroughAsyncInterceptors(key)).toThrow(/disposed/);
+ const filter = vi.fn(() => true);
+ expect(() => manager.fetchThroughAsyncInterceptors(key, filter)).toThrow(/disposed/);
+ expect(filter).not.toHaveBeenCalled();
+ expect(release()).toBe(false);
+ expect(release()).toBe(false);
+ });
+
+ it('only unregisters from the requested interception point', async () => {
+ const first = createAsyncInterceptorKey<boolean, null>('first');
+ const second = createAsyncInterceptorKey<boolean, null>('second');
+ const manager = createAsyncManager({ first, second });
+ const handler = { handler: async () => true };
+ const release = await manager.interceptAsync(first, handler);
+ await manager.interceptAsync(second, handler);
+ release();
+ expect(await manager.fetchThroughAsyncInterceptors(first)(false, null)).toBe(false);
+ expect(await manager.fetchThroughAsyncInterceptors(second)(false, null)).toBe(true);
+ });
+
+ it('rejects later invocations of cached and filtered chains after disposal', async () => {
+ const key = createAsyncInterceptorKey<boolean, null>('cached-chain');
+ const manager = createAsyncManager({ key });
+ const handler = vi.fn(async () => true);
+ await manager.interceptAsync(key, { handler });
+ const chain = manager.fetchThroughAsyncInterceptors(key);
+ const filtered = manager.fetchThroughAsyncInterceptors(key, () => true);
+ manager.dispose();
+ await expect(chain(false, null)).rejects.toThrow(/disposed/);
+ await expect(filtered(false, null)).rejects.toThrow(/disposed/);
+ expect(handler).not.toHaveBeenCalled();
+ });
+
+ it('remains terminal when an owned cleanup throws', async () => {
+ const key = createAsyncInterceptorKey<boolean, null>('cleanup-error');
+ const manager = createAsyncManager({ key });
+ const release = await manager.interceptAsync(key, { handler: async () => true });
+ const error = new Error('cleanup failed');
+ manager.disposeWithMe(() => {
+ throw error;
+ });
+ expect(() => manager.dispose()).toThrow(error);
+ await expect(manager.interceptAsync(key, { handler: async () => true })).rejects.toThrow(/disposed/);
+ expect(release()).toBe(false);
+ expect(() => manager.dispose()).not.toThrow();
+ });
+
+ it('lets an in-flight chain complete after terminal disposal', async () => {
+ const key = createAsyncInterceptorKey<number, null>('in-flight');
+ const manager = createAsyncManager({ key });
+ let resume = () => {};
+ const pending = new Promise<void>((resolve) => {
+ resume = resolve;
+ });
+ await manager.interceptAsync(key, {
+ priority: 10,
+ handler: async (value, _context, next) => {
+ await pending;
+ return next(value! + 1);
+ },
+ });
+ await manager.interceptAsync(key, { handler: async (value, _context, next) => next(value! * 2) });
+ const result = manager.fetchThroughAsyncInterceptors(key)(1, null);
+ manager.dispose();
+ await expect(manager.interceptAsync(key, { handler: async () => 100 })).rejects.toThrow(/disposed/);
+ resume();
+ expect(await result).toBe(4);
+ expect(() => manager.fetchThroughAsyncInterceptors(key)).toThrow(/disposed/);
+ });
+});
diff --git a/packages/core/src/common/interceptor.ts b/packages/core/src/common/interceptor.ts
index b7117acf26..e580940f5a 100644
--- a/packages/core/src/common/interceptor.ts
+++ b/packages/core/src/common/interceptor.ts
@@ -17,6 +17,7 @@
/* eslint-disable ts/no-explicit-any */
import type { Nullable } from '../shared/types';
+import { Disposable } from '../shared/lifecycle';
import { remove } from './array';
export type InterceptorHandler<M = unknown, C = unknown> = (
@@ -89,11 +90,12 @@ export const composeInterceptors = <T, C>(interceptors: Array<IInterceptor<T, C>
return value;
} as ReturnType<IComposeInterceptors<T, C>>;
-export class InterceptorManager<P extends Record<string, IInterceptor<any, any>>> {
+export class InterceptorManager<P extends Record<string, IInterceptor<any, any>>> extends Disposable {
private _interceptorsByName: Map<string, Array<IInterceptor<unknown, unknown>>> = new Map();
private _interceptorPoints: P;
constructor(interceptorPoints: P) {
+ super();
this._interceptorPoints = interceptorPoints;
}
@@ -103,8 +105,10 @@ export class InterceptorManager<P extends Record<string, IInterceptor<any, any>>
* @param filter A callback function to filter the interceptors.
* @returns It will return a composed interceptor function. If you will perform the interceptor repeatedly,
* you should cache the result instead of calling this function multiple times.
+ * A cached chain cannot start a new call after this manager is disposed.
*/
public fetchThroughInterceptors<T, C>(name: IInterceptor<T, C>, filter?: (interceptor: IInterceptor<any, any>) => boolean) {
+ this.ensureNotDisposed();
const key = name as unknown as string;
let interceptors = this._interceptorsByName.get(key) as unknown as Array<typeof name>;
@@ -112,10 +116,15 @@ export class InterceptorManager<P extends Record<string, IInterceptor<any, any>>
interceptors = interceptors.filter(filter);
}
- return composeInterceptors(interceptors || []);
+ const handler = composeInterceptors(interceptors || []);
+ return (initialValue: Nullable<T>, context: C) => {
+ this.ensureNotDisposed();
+ return handler(initialValue, context);
+ };
}
public intercept<T extends IInterceptor<any, any>>(name: T, interceptor: T) {
+ this.ensureNotDisposed();
const key = name as unknown as string;
if (!this._interceptorsByName.has(key)) {
this._interceptorsByName.set(key, []);
@@ -127,15 +136,26 @@ export class InterceptorManager<P extends Record<string, IInterceptor<any, any>>
key,
interceptors.sort((a, b) => (b.priority ?? 0) - (a.priority ?? 0)) // from large to small
);
- return () => remove(this._interceptorsByName.get(key)!, interceptor);
+ let registration: T | undefined = interceptor;
+ return () => {
+ const current = registration;
+ registration = undefined;
+ if (!current || this._disposed) {
+ return false;
+ }
+
+ const list = this._interceptorsByName.get(key);
+ return list ? remove(list, current) : false;
+ };
}
public getInterceptPoints() {
return this._interceptorPoints;
}
- public dispose() {
+ public override dispose() {
this._interceptorsByName.clear();
+ super.dispose();
}
}
@@ -198,11 +218,12 @@ export const composeAsyncInterceptors = <T, C>(
};
};
-export class AsyncInterceptorManager<P extends Record<string, IAsyncInterceptor<any, any>>> {
+export class AsyncInterceptorManager<P extends Record<string, IAsyncInterceptor<any, any>>> extends Disposable {
private _asyncInterceptorsByName: Map<string, Array<IAsyncInterceptor<unknown, unknown>>> = new Map();
private _asyncInterceptorPoints: P;
constructor(asyncInterceptorPoints: P) {
+ super();
this._asyncInterceptorPoints = asyncInterceptorPoints;
}
@@ -212,8 +233,10 @@ export class AsyncInterceptorManager<P extends Record<string, IAsyncInterceptor<
* @param filter A callback function to filter the interceptors.
* @returns It will return a composed interceptor function. If you will perform the interceptor repeatedly,
* you should cache the result instead of calling this function multiple times.
+ * A cached chain cannot start a new call after this manager is disposed.
*/
public fetchThroughAsyncInterceptors<T, C>(name: IAsyncInterceptor<T, C>, filter?: (interceptor: IAsyncInterceptor<any, any>) => boolean) {
+ this.ensureNotDisposed();
const key = name as unknown as string;
let interceptors = this._asyncInterceptorsByName.get(key) as unknown as Array<typeof name>;
@@ -221,10 +244,15 @@ export class AsyncInterceptorManager<P extends Record<string, IAsyncInterceptor<
interceptors = interceptors.filter(filter);
}
- return composeAsyncInterceptors(interceptors || []);
+ const handler = composeAsyncInterceptors(interceptors || []);
+ return async (initialValue: Nullable<T>, context: C) => {
+ this.ensureNotDisposed();
+ return handler(initialValue, context);
+ };
}
public async interceptAsync<T extends IAsyncInterceptor<any, any>>(name: T, interceptor: T) {
+ this.ensureNotDisposed();
const key = name as unknown as string;
if (!this._asyncInterceptorsByName.has(key)) {
this._asyncInterceptorsByName.set(key, []);
@@ -237,14 +265,25 @@ export class AsyncInterceptorManager<P extends Record<string, IAsyncInterceptor<
key,
interceptors.sort((a, b) => (b.priority ?? 0) - (a.priority ?? 0)) // from large to small
);
- return () => remove(this._asyncInterceptorsByName.get(key)!, interceptor);
+ let registration: T | undefined = interceptor;
+ return () => {
+ const current = registration;
+ registration = undefined;
+ if (!current || this._disposed) {
+ return false;
+ }
+
+ const list = this._asyncInterceptorsByName.get(key);
+ return list ? remove(list, current) : false;
+ };
}
public getInterceptPoints() {
return this._asyncInterceptorPoints;
}
- public dispose() {
+ public override dispose() {
this._asyncInterceptorsByName.clear();
+ super.dispose();
}
}
diff --git a/packages/docs-ui/src/views/mobile-doc-toolbar/MobileDocToolbar.tsx b/packages/docs-ui/src/views/mobile-doc-toolbar/MobileDocToolbar.tsx
index 086e33d496..384d584f06 100644
--- a/packages/docs-ui/src/views/mobile-doc-toolbar/MobileDocToolbar.tsx
+++ b/packages/docs-ui/src/views/mobile-doc-toolbar/MobileDocToolbar.tsx
@@ -16,9 +16,7 @@
import type { IMenuSchema, IValueOption, MobileDrawerSnap } from '@univerjs/ui';
import type { ReactNode } from 'react';
-import type { LocaleKey } from '../../locale/types';
-import type { MobileDocSelectionRenderService } from '../../services/mobile/doc-selection-render.service';
-import { ICommandService, IUniverInstanceService, LocaleService, UniverInstanceType } from '@univerjs/core';
+import { ICommandService, Injector, IUniverInstanceService, LocaleService, UniverInstanceType } from '@univerjs/core';
import { clsx, resetButtonClassName } from '@univerjs/design';
import { IRenderManagerService } from '@univerjs/engine-render';
import {
@@ -44,11 +42,14 @@ import {
useObservable,
} from '@univerjs/ui';
import { useCallback, useEffect, useMemo, useState } from 'react';
-import { map, startWith } from 'rxjs';
+import { map, of, startWith } from 'rxjs';
+import type { LocaleKey } from '../../locale/types';
+import type { MobileDocSelectionRenderService } from '../../services/mobile/doc-selection-render.service';
import {
DOC_PARAGRAPH_T_ALIGN_MENU_ID,
DOC_PARAGRAPH_T_EDIT_MENU_ID,
} from '../../menu/paragraph-menu';
+import { IDocEmbedRuntimeFocusCoordinator } from '../../services/doc-embed-integration.service';
import { IEditorService } from '../../services/editor/editor-manager.service';
import { DocSelectionRenderService } from '../../services/selection/doc-selection-render.service';
@@ -193,6 +194,7 @@ function useMobileDocEditState() {
selectionService?.isMobileEditMode ?? false
);
return {
+ unitId,
isEditing,
isReadOnly: unitId ? editorService.getEditor(unitId)?.isReadOnly() === true : true,
selectionService,
@@ -231,7 +233,17 @@ export function MobileDocToolbar() {
const menuManagerService = useDependency(IMenuManagerService);
const workbenchService = useDependency(IWorkbenchService);
const rootUnitType = useObservable(workbenchService.rootUnitType$, null, true);
- const { isEditing, isReadOnly, selectionService } = useMobileDocEditState();
+ const { unitId, isEditing, isReadOnly, selectionService } = useMobileDocEditState();
+ const injector = useDependency(Injector);
+ const focusCoordinator = injector.has(IDocEmbedRuntimeFocusCoordinator)
+ ? injector.get(IDocEmbedRuntimeFocusCoordinator)
+ : undefined;
+ const embeddedDocActive = useObservable(
+ () => focusCoordinator?.runtimeSessionChanged$.pipe(startWith(undefined), map(() => focusCoordinator.isChildUnitInActiveSession(unitId))) ?? of(false),
+ focusCoordinator?.isChildUnitInActiveSession(unitId) ?? false,
+ false,
+ [focusCoordinator, unitId]
+ );
const keyboardState = useObservable(
selectionService?.mobileKeyboardState$,
{ visible: false, inset: 0 }
@@ -265,7 +277,7 @@ export function MobileDocToolbar() {
}, [selectionService, closeDrawer]);
const drawerSchemas = useMemo(() => drawer ? menuSchemas[drawer] : [], [drawer, menuSchemas]);
- if (rootUnitType !== UniverInstanceType.UNIVER_DOC) {
+ if (rootUnitType !== UniverInstanceType.UNIVER_DOC && !embeddedDocActive) {
return null;
}
@@ -279,7 +291,7 @@ export function MobileDocToolbar() {
type="button"
aria-label={localeService.t<LocaleKey>('docs-ui.mobile.edit')}
className={clsx(resetButtonClassName, `
- univer-pointer-events-auto univer-absolute univer-bottom-4 univer-z-30 univer-flex univer-size-14
+ univer-pointer-events-auto univer-absolute univer-bottom-4 univer-z-50 univer-flex univer-size-14
univer-items-center univer-justify-center univer-rounded-full univer-bg-primary-600 univer-text-2xl
univer-text-white univer-shadow-lg
active:univer-scale-95 active:univer-bg-primary-700
@@ -356,7 +368,7 @@ export function MobileDocToolbar() {
{keyboardVisible && quickMenu && (
<div
className="
- univer-pointer-events-auto univer-absolute univer-inset-x-3 univer-z-30 univer-overflow-hidden
+ univer-pointer-events-auto univer-absolute univer-inset-x-3 univer-z-50 univer-overflow-hidden
"
style={{ bottom: `${keyboardState.inset + 48}px` }}
>
@@ -371,7 +383,7 @@ export function MobileDocToolbar() {
{keyboardVisible && !drawer && (
<div
className="
- univer-pointer-events-auto univer-absolute univer-inset-x-0 univer-z-30 univer-box-border
+ univer-pointer-events-auto univer-absolute univer-inset-x-0 univer-z-50 univer-box-border
univer-flex univer-h-12 univer-items-center univer-gap-0.5 univer-border-0 univer-border-t
univer-border-solid univer-border-gray-200 univer-bg-gray-0 univer-px-1
dark:!univer-border-gray-700 dark:!univer-bg-gray-800
diff --git a/packages/docs-ui/src/views/mobile-rich-text-toolbar/MobileRichTextToolbar.tsx b/packages/docs-ui/src/views/mobile-rich-text-toolbar/MobileRichTextToolbar.tsx
index bf32ea5405..c25181be6f 100644
--- a/packages/docs-ui/src/views/mobile-rich-text-toolbar/MobileRichTextToolbar.tsx
+++ b/packages/docs-ui/src/views/mobile-rich-text-toolbar/MobileRichTextToolbar.tsx
@@ -155,10 +155,8 @@ export function MobileRichTextToolbar({ editorId, className }: IMobileRichTextTo
univer-box-border univer-bg-gray-0 univer-shadow-[0_1px_0_rgba(0,0,0,0.06)]
dark:!univer-bg-gray-800
`, className)}
- onPointerDown={(event) => {
- event.preventDefault();
- event.stopPropagation();
- }}
+ onPointerDown={(event) => event.stopPropagation()}
+ onMouseDown={(event) => event.preventDefault()}
>
{!colorsVisible
? (
diff --git a/packages/engine-render/src/__tests__/context.spec.ts b/packages/engine-render/src/__tests__/context.spec.ts
index c53be68e36..c0494366fe 100644
--- a/packages/engine-render/src/__tests__/context.spec.ts
+++ b/packages/engine-render/src/__tests__/context.spec.ts
@@ -14,8 +14,12 @@
* limitations under the License.
*/
-import { afterEach, describe, expect, it, vi } from 'vitest';
+import { Injector, ThemeService } from '@univerjs/core';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
import { UniverPrintingContext, UniverRenderingContext2D } from '../context';
+import { CanvasColorService, ICanvasColorService } from '../services/canvas-color.service';
+
+let injector: Injector;
function createNativeContext() {
const canvas = document.createElement('canvas');
@@ -107,24 +111,103 @@ function createNativeContext() {
}
describe('canvas context', () => {
+ beforeEach(() => {
+ injector = new Injector([[ThemeService], [ICanvasColorService, { useClass: CanvasColorService }]]);
+ });
+
+ afterEach(() => injector.dispose());
+
afterEach(() => vi.restoreAllMocks());
+ it('reuses scale during a drawing scope without sharing mutable public transform snapshots', () => {
+ const native = createNativeContext();
+ const ctx = injector.createChild([[UniverRenderingContext2D, { useFactory: function createTestInstance() {
+ return injector.createInstance(UniverRenderingContext2D, native);
+ } }]]).get(UniverRenderingContext2D);
+ ctx.withCachedScale(() => {
+ expect(ctx.getScale()).toEqual({ scaleX: 2, scaleY: 4 });
+ ctx.moveToByPrecision(1.2, 2.3);
+ ctx.lineToByPrecision(3.4, 4.5);
+ expect(native.getTransform).toHaveBeenCalledTimes(1);
+ const snapshot = ctx.getTransform();
+ snapshot.a = 99;
+ expect(ctx.getTransform().a).toBe(2);
+ expect(ctx.getScale()).toEqual({ scaleX: 2, scaleY: 4 });
+ });
+ expect(native.moveTo).toHaveBeenCalledWith(1, 2.25);
+ expect(native.lineTo).toHaveBeenCalledWith(3.5, 4.5);
+ vi.mocked(native.getTransform).mockReturnValue({ a: 3, b: 4, c: 0, d: 6 } as DOMMatrix);
+ expect(ctx.getScale()).toEqual({ scaleX: 5, scaleY: 6 });
+ });
+
+ it.each([
+ (ctx: UniverRenderingContext2D) => ctx.restore(),
+ (ctx: UniverRenderingContext2D) => ctx.reset(),
+ (ctx: UniverRenderingContext2D) => ctx.resetTransform(),
+ (ctx: UniverRenderingContext2D) => ctx.rotate(0.3),
+ (ctx: UniverRenderingContext2D) => ctx.scale(2, 3),
+ (ctx: UniverRenderingContext2D) => ctx.setTransform(1, 0, 0, 1, 2, 3),
+ (ctx: UniverRenderingContext2D) => ctx.transform(1, 0, 0, 1, 2, 3),
+ (ctx: UniverRenderingContext2D) => ctx.translate(2, 3),
+ (ctx: UniverRenderingContext2D) => ctx.translateWithPrecision(2, 3),
+ (ctx: UniverRenderingContext2D) => ctx.translateWithPrecisionRatio(2, 3),
+ ])('refreshes scoped scale after a context transformation (%#)', (transform) => {
+ const native = createNativeContext();
+ const ctx = injector.createChild([[UniverRenderingContext2D, { useFactory: function createTestInstance() {
+ return injector.createInstance(UniverRenderingContext2D, native);
+ } }]]).get(UniverRenderingContext2D);
+ ctx.withCachedScale(() => {
+ expect(ctx.getScale()).toEqual({ scaleX: 2, scaleY: 4 });
+ vi.mocked(native.getTransform).mockReturnValue({ a: 0, b: 3, c: 5, d: 0 } as DOMMatrix);
+ transform(ctx);
+ expect(ctx.getScale()).toEqual({ scaleX: 3, scaleY: 5 });
+ });
+ });
+
+ it('clears nested and failed drawing scopes and leaves ordinary scale reads live', () => {
+ const native = createNativeContext();
+ const ctx = injector.createChild([[UniverRenderingContext2D, { useFactory: function createTestInstance() {
+ return injector.createInstance(UniverRenderingContext2D, native);
+ } }]]).get(UniverRenderingContext2D);
+ ctx.withCachedScale(() => {
+ expect(ctx.getScale().scaleX).toBe(2);
+ expect(() => ctx.withCachedScale(() => {
+ expect(ctx.getScale().scaleX).toBe(2);
+ throw new Error('draw failed');
+ })).toThrow('draw failed');
+ vi.mocked(native.getTransform).mockReturnValue({ a: 7, b: 0, c: 0, d: 8 } as DOMMatrix);
+ expect(ctx.getScale()).toEqual({ scaleX: 7, scaleY: 8 });
+ ctx.getScale();
+ expect(native.getTransform).toHaveBeenCalledTimes(3);
+ });
+ ctx.getScale();
+ ctx.getScale();
+ expect(native.getTransform).toHaveBeenCalledTimes(5);
+ expect(() => ctx.withCachedScale(() => {
+ ctx.getScale();
+ throw new Error('outer draw failed');
+ })).toThrow('outer draw failed');
+ vi.mocked(native.getTransform).mockReturnValue({ a: 9, b: 0, c: 0, d: 10 } as DOMMatrix);
+ expect(ctx.getScale()).toEqual({ scaleX: 9, scaleY: 10 });
+ });
+
it('forwards style and basic drawing calls', () => {
const nativeCtx = createNativeContext();
- const renderCtx = new UniverRenderingContext2D(nativeCtx, {
- canvasColorService: {
- getRenderColor: (color: string) => `render-${color}`,
- } as any,
- });
+ const renderCtx = injector.createChild([[UniverRenderingContext2D, { useFactory: function createTestInstance() {
+ return injector.createInstance(UniverRenderingContext2D, nativeCtx, {
+ canvasColorService: injector.get(ICanvasColorService),
+ });
+ } }]]).get(UniverRenderingContext2D);
renderCtx.setId('ctx-id');
expect(renderCtx.getId()).toBe('ctx-id');
expect(renderCtx.isContextLost()).toBe(false);
- renderCtx.fillStyle = '#111111';
- renderCtx.strokeStyle = '#222222';
- expect(nativeCtx.fillStyle).toBe('render-#111111');
- expect(nativeCtx.strokeStyle).toBe('render-#222222');
+ renderCtx.fillStyle = 'primary.500';
+ renderCtx.strokeStyle = 'gray.700';
+ const theme = injector.get(ThemeService).getCurrentTheme();
+ expect(nativeCtx.fillStyle).toBe(theme.primary[500]);
+ expect(nativeCtx.strokeStyle).toBe(theme.gray[700]);
renderCtx.globalAlpha = 0.7;
renderCtx.globalCompositeOperation = 'multiply';
@@ -190,7 +273,9 @@ describe('canvas context', () => {
it('covers precision, drawImage, createImageData and env branches', () => {
const nativeCtx = createNativeContext();
- const renderCtx = new UniverRenderingContext2D(nativeCtx);
+ const renderCtx = injector.createChild([[UniverRenderingContext2D, { useFactory: function createTestInstance() {
+ return injector.createInstance(UniverRenderingContext2D, nativeCtx);
+ } }]]).get(UniverRenderingContext2D);
renderCtx.roundRectByPrecision(1, 2, 3, 4, 2);
renderCtx.arcByPrecision(1, 2, 5, 0, Math.PI);
@@ -226,13 +311,17 @@ describe('canvas context', () => {
renderCtx.closePathByEnv();
expect(nativeCtx.closePath).not.toHaveBeenCalled();
userAgentSpy.mockReturnValue('Mozilla/5.0 (Macintosh; Intel Mac OS X) Gecko/20100101 Firefox/130.0');
- new UniverRenderingContext2D(nativeCtx).closePathByEnv();
+ injector.createChild([[UniverRenderingContext2D, { useFactory: function createTestInstance() {
+ return injector.createInstance(UniverRenderingContext2D, nativeCtx);
+ } }]]).get(UniverRenderingContext2D).closePathByEnv();
expect(nativeCtx.closePath).toHaveBeenCalledTimes(1);
});
it('forwards text language in both directions', () => {
const nativeCtx = createNativeContext();
- const renderCtx = new UniverRenderingContext2D(nativeCtx);
+ const renderCtx = injector.createChild([[UniverRenderingContext2D, { useFactory: function createTestInstance() {
+ return injector.createInstance(UniverRenderingContext2D, nativeCtx);
+ } }]]).get(UniverRenderingContext2D);
nativeCtx.lang = 'ja';
expect(renderCtx.lang).toBe('ja');
@@ -244,7 +333,9 @@ describe('canvas context', () => {
it('inherits text language when the native context has no language property', () => {
const nativeCtx = createNativeContext();
delete (nativeCtx as Partial<CanvasRenderingContext2D>).lang;
- const renderCtx = new UniverRenderingContext2D(nativeCtx);
+ const renderCtx = injector.createChild([[UniverRenderingContext2D, { useFactory: function createTestInstance() {
+ return injector.createInstance(UniverRenderingContext2D, nativeCtx);
+ } }]]).get(UniverRenderingContext2D);
expect(renderCtx.lang).toBe('inherit');
@@ -259,7 +350,9 @@ describe('canvas context', () => {
])('draws rounded corners with radius $radius without native roundRect on Chrome 88', ({ radius, expectedRadius }) => {
const nativeCtx = createNativeContext();
delete (nativeCtx as Partial<CanvasRenderingContext2D>).roundRect;
- const renderCtx = new UniverRenderingContext2D(nativeCtx);
+ const renderCtx = injector.createChild([[UniverRenderingContext2D, { useFactory: function createTestInstance() {
+ return injector.createInstance(UniverRenderingContext2D, nativeCtx);
+ } }]]).get(UniverRenderingContext2D);
renderCtx.roundRect(10, 20, 40, 20, radius);
@@ -276,7 +369,9 @@ describe('canvas context', () => {
it.each([undefined, 0])('draws a rectangle with radius %s without native roundRect on Chrome 88', (radius) => {
const nativeCtx = createNativeContext();
delete (nativeCtx as Partial<CanvasRenderingContext2D>).roundRect;
- const renderCtx = new UniverRenderingContext2D(nativeCtx);
+ const renderCtx = injector.createChild([[UniverRenderingContext2D, { useFactory: function createTestInstance() {
+ return injector.createInstance(UniverRenderingContext2D, nativeCtx);
+ } }]]).get(UniverRenderingContext2D);
renderCtx.roundRect(10, 20, 40, 20, radius);
@@ -286,7 +381,9 @@ describe('canvas context', () => {
it('forwards native rounded rectangles and line dashes', () => {
const nativeCtx = createNativeContext();
- const renderCtx = new UniverRenderingContext2D(nativeCtx);
+ const renderCtx = injector.createChild([[UniverRenderingContext2D, { useFactory: function createTestInstance() {
+ return injector.createInstance(UniverRenderingContext2D, nativeCtx);
+ } }]]).get(UniverRenderingContext2D);
const radii = [{ x: 4, y: 2 }, 8];
renderCtx.roundRect(10, 20, 40, 20, radii);
@@ -298,7 +395,9 @@ describe('canvas context', () => {
it('clears the printing context without changing its compositing mode', () => {
const nativeCtx = createNativeContext();
- const printingCtx = new UniverPrintingContext(nativeCtx);
+ const printingCtx = injector.createChild([[UniverPrintingContext, { useFactory: function createTestInstance() {
+ return injector.createInstance(UniverPrintingContext, nativeCtx);
+ } }]]).get(UniverPrintingContext);
printingCtx.clearRect(1, 2, 3, 4);
printingCtx.clearRectForTexture(1, 2, 3, 4);
printingCtx.setGlobalCompositeOperation('lighter');
@@ -312,7 +411,9 @@ describe('canvas context', () => {
it('reads proxied state and helper factories from the native context', () => {
const nativeCtx = createNativeContext();
- const renderCtx = new UniverRenderingContext2D(nativeCtx);
+ const renderCtx = injector.createChild([[UniverRenderingContext2D, { useFactory: function createTestInstance() {
+ return injector.createInstance(UniverRenderingContext2D, nativeCtx);
+ } }]]).get(UniverRenderingContext2D);
expect(renderCtx.globalAlpha).toBe(1);
expect(renderCtx.globalCompositeOperation).toBe('source-over');
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 c8e2f0a8f2..d77f0382a1 100644
--- a/packages/engine-render/src/__tests__/engine-scene-viewport.spec.ts
+++ b/packages/engine-render/src/__tests__/engine-scene-viewport.spec.ts
@@ -14,7 +14,7 @@
* limitations under the License.
*/
-import { Tools } from '@univerjs/core';
+import { Injector, Tools } from '@univerjs/core';
import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
import { CURSOR_TYPE } from '../basics/const';
import { DeviceType, PointerInput } from '../basics/i-events';
@@ -22,11 +22,14 @@ import { Vector2 } from '../basics/vector2';
import { Engine } from '../engine';
import { Group } from '../group';
import { MAIN_VIEW_PORT_KEY, Scene } from '../scene';
+import { DumbCanvasColorService, ICanvasColorService } from '../services/canvas-color.service';
import { Rect } from '../shape/rect';
import { ScrollBar } from '../shape/scroll-bar';
import { Viewport } from '../viewport';
import { setupRenderTestEnv } from './render-test-utils';
+let injector: Injector;
+
interface IFixture {
engine: Engine;
scene: Scene;
@@ -65,10 +68,12 @@ function createFixture(): IFixture {
container.style.border = '1px solid transparent';
document.body.appendChild(container);
- const engine = new Engine('unit-a', { elementWidth: 320, elementHeight: 180, dpr: 1 });
+ const engine = injector.createChild([[Engine, { useFactory: function createTestInstance() {
+ return injector.createInstance(Engine, 'unit-a', { elementWidth: 320, elementHeight: 180, dpr: 1 });
+ } }]]).get(Engine);
engine.mount(container, false);
- const scene = new Scene('scene-a', engine);
+ const scene = injector.createInstance(Scene, 'scene-a', engine);
scene.transformByState({
width: 700,
height: 500,
@@ -76,7 +81,7 @@ function createFixture(): IFixture {
scaleY: 1,
});
- const viewport = new Viewport(MAIN_VIEW_PORT_KEY, scene, {
+ const viewport = injector.createInstance(Viewport, MAIN_VIEW_PORT_KEY, scene, {
left: 0,
top: 0,
width: 300,
@@ -87,13 +92,13 @@ function createFixture(): IFixture {
bufferEdgeY: 6,
});
- new ScrollBar(viewport, {
+ injector.createInstance(ScrollBar, viewport, {
mainScene: scene,
barSize: 12,
thumbMargin: 2,
});
- const rect = new Rect('rect-main', {
+ const rect = injector.createInstance(Rect, 'rect-main', {
left: 10,
top: 10,
width: 100,
@@ -105,7 +110,7 @@ function createFixture(): IFixture {
rect.zIndex = 1;
scene.addObject(rect, 1);
- const child = new Rect('rect-child', {
+ const child = injector.createInstance(Rect, 'rect-child', {
left: 120,
top: 40,
width: 60,
@@ -114,7 +119,7 @@ function createFixture(): IFixture {
stroke: '#111111',
strokeWidth: 1,
});
- const group = new Group('group-main', child);
+ const group = injector.createInstance(Group, 'group-main', child);
group.transformByState({ left: 40, top: 20 });
scene.addObject(group, 2);
@@ -126,15 +131,46 @@ function createFixture(): IFixture {
};
}
+function createViewportCacheFixture(bottom = 40, dpr = 1) {
+ const engine = injector.createChild([[Engine, { useFactory: function createTestInstance() {
+ return injector.createInstance(Engine, 'viewport-cache-engine', { elementWidth: 320, elementHeight: 180, dpr });
+ } }]]).get(Engine);
+ const scene = injector.createInstance(Scene, 'viewport-cache-scene', engine);
+ scene.transformByState({ width: 700, height: 500, scaleX: 1, scaleY: 1 });
+ const top = injector.createInstance(Viewport, 'viewMainTop', scene, { left: 0, top: 0, width: 300, height: bottom, active: true, allowCache: true });
+ const main = injector.createInstance(Viewport, MAIN_VIEW_PORT_KEY, scene, { left: 0, top: bottom, width: 300, height: 180 - bottom, active: true, allowCache: true });
+ const object = injector.createInstance(Rect, 'viewport-cache-rect', { left: 5, top: 5, width: 40, height: 20, fill: '#44aa66' });
+ object.viewportCacheReusable = true;
+ scene.addObject(object, 1);
+ scene.enableLayerCache(1);
+ scene.setViewportCacheReuseKey(MAIN_VIEW_PORT_KEY);
+ engine.resizeBySize(320, 180);
+ scene.render();
+ const retained = vi.spyOn(top, 'reuseCachedRender');
+ const painted = vi.spyOn(top, 'render');
+ const rootClear = vi.spyOn(engine, 'clearCanvas');
+ const scroll = (x = 0, y = 20) => {
+ main.viewportScrollX += x;
+ main.viewportScrollY += y;
+ scene.makeDirtyForViewportScroll(main);
+ };
+ const dispose = () => {
+ scene.dispose();
+ };
+ return { engine, scene, top, main, object, retained, painted, rootClear, scroll, dispose };
+}
+
describe('engine scene viewport extra', () => {
let env: ReturnType<typeof setupRenderTestEnv>;
beforeEach(() => {
+ injector = new Injector([[ICanvasColorService, { useClass: DumbCanvasColorService }]]);
env = setupRenderTestEnv();
vi.useFakeTimers();
});
afterEach(() => {
+ injector.dispose();
vi.runOnlyPendingTimers();
vi.useRealTimers();
env.restore();
@@ -142,15 +178,134 @@ describe('engine scene viewport extra', () => {
document.body.innerHTML = '';
});
+ it('retains the frozen cache band across consecutive vertical scrolls and still clears the root', () => {
+ const fixture = createViewportCacheFixture();
+ const bookkeeping = vi.spyOn(fixture.object, 'onViewportCacheReuse');
+ try {
+ fixture.scroll();
+ fixture.scroll();
+ expect(fixture.scene.isViewportCacheReusePending()).toBe(true);
+ fixture.scene.render();
+ expect(fixture.retained).toHaveBeenCalledOnce();
+ expect(fixture.painted).not.toHaveBeenCalled();
+ expect(bookkeeping).toHaveBeenCalledOnce();
+ expect(fixture.rootClear).toHaveBeenCalledOnce();
+ expect(fixture.top.isDirty).toBe(false);
+ expect(fixture.top.isForceDirty).toBe(false);
+ fixture.scroll();
+ fixture.scene.render();
+ expect(fixture.retained).toHaveBeenCalledTimes(2);
+ } finally {
+ fixture.dispose();
+ }
+ });
+
+ it.each(['scene', 'unknown-command', 'object', 'hide', 'remove', 'clear', 'viewport', 'force-viewport', 'resize', 'horizontal', 'unsupported'] as const)(
+ 'falls back when %s invalidates a pending frozen cache',
+ (reason) => {
+ const fixture = createViewportCacheFixture();
+ try {
+ fixture.scroll();
+ expect(fixture.scene.isViewportCacheReusePending()).toBe(true);
+ switch (reason) {
+ case 'scene':
+ fixture.scene.makeDirty(true);
+ break;
+ case 'unknown-command':
+ fixture.scene.invalidateViewportCacheReuse();
+ break;
+ case 'object':
+ fixture.object.makeDirty(true);
+ break;
+ case 'hide':
+ fixture.object.hide();
+ break;
+ case 'remove':
+ fixture.scene.removeObject(fixture.object);
+ break;
+ case 'clear':
+ fixture.scene.getLayer(1).clear();
+ break;
+ case 'viewport':
+ fixture.top.markDirty(true);
+ break;
+ case 'force-viewport':
+ fixture.top.markForceDirty(true);
+ break;
+ case 'resize':
+ fixture.engine.resizeBySize(330, 180);
+ break;
+ case 'horizontal':
+ fixture.main.viewportScrollX = 1;
+ break;
+ case 'unsupported':
+ fixture.object.viewportCacheReusable = false;
+ break;
+ }
+ fixture.scene.render();
+ expect(fixture.retained).not.toHaveBeenCalled();
+ expect(fixture.painted).toHaveBeenCalledOnce();
+ } finally {
+ fixture.dispose();
+ }
+ }
+ );
+
+ it('does not resurrect invalidated intent when another relative scroll arrives before paint', () => {
+ const fixture = createViewportCacheFixture();
+ try {
+ fixture.scroll();
+ fixture.scene.invalidateViewportCacheReuse();
+ fixture.scroll();
+ fixture.scene.render();
+ expect(fixture.retained).not.toHaveBeenCalled();
+ fixture.scroll();
+ fixture.scene.render();
+ expect(fixture.retained).toHaveBeenCalledOnce();
+ } finally {
+ fixture.dispose();
+ }
+ });
+
+ it.each([20.5, 21])('rejects fractional cache pixels at boundary %s', (bottom) => {
+ Object.defineProperty(window, 'devicePixelRatio', { configurable: true, value: 1.25 });
+ const fixture = createViewportCacheFixture(bottom, 2);
+ try {
+ fixture.scroll();
+ fixture.scene.render();
+ expect(fixture.retained).not.toHaveBeenCalled();
+ expect(fixture.painted).toHaveBeenCalledOnce();
+ } finally {
+ fixture.dispose();
+ Object.defineProperty(window, 'devicePixelRatio', { configurable: true, value: 1 });
+ }
+ });
+
+ it('keeps before-render subscribers on the full rendering path', () => {
+ const fixture = createViewportCacheFixture();
+ const subscription = fixture.scene.beforeRender$.subscribe(() => {});
+ try {
+ fixture.scroll();
+ fixture.scene.render();
+ expect(fixture.retained).not.toHaveBeenCalled();
+ expect(fixture.painted).toHaveBeenCalledOnce();
+ } finally {
+ subscription.unsubscribe();
+ fixture.dispose();
+ }
+ });
+
it('keeps wheel scrolling visually consistent when the scene is scaled', () => {
const getViewportWheelDelta = (scale: number) => {
const container = document.createElement('div');
document.body.appendChild(container);
- const engine = new Engine('unit-wheel', { elementWidth: 320, elementHeight: 180, dpr: 1 });
+ const engine = injector.createChild([[Engine, { useFactory: function createTestInstance() {
+ return injector.createInstance(Engine, 'unit-wheel', { elementWidth: 320, elementHeight: 180, dpr: 1 });
+ } }]]).get(Engine);
engine.mount(container, false);
- const scene = new Scene('scene-wheel', engine);
+ const scene = injector.createInstance(Scene, 'scene-wheel', engine);
scene.transformByState({
width: 700,
height: 500,
@@ -158,7 +313,7 @@ describe('engine scene viewport extra', () => {
scaleY: 1,
});
- const viewport = new Viewport('doc-like-vp', scene, {
+ const viewport = injector.createInstance(Viewport, 'doc-like-vp', scene, {
left: 0,
top: 0,
right: 0,
@@ -166,7 +321,7 @@ describe('engine scene viewport extra', () => {
active: true,
});
- new ScrollBar(viewport);
+ injector.createInstance(ScrollBar, viewport);
scene.scale(scale, scale);
viewport.resetCanvasSizeAndUpdateScroll();
@@ -177,7 +332,6 @@ describe('engine scene viewport extra', () => {
const delta = viewport.viewportScrollY;
scene.dispose();
- engine.dispose();
container.remove();
return delta;
@@ -189,6 +343,30 @@ describe('engine scene viewport extra', () => {
expect(doubleScaleDelta * 2).toBeCloseTo(normalScaleDelta, 3);
});
+ it('keeps clamped scroll notifications without repainting an unchanged clean viewport', () => {
+ const { engine, scene, viewport, container } = createFixture();
+ viewport.scrollToViewportPos({ viewportScrollX: 0, viewportScrollY: 0 });
+ viewport.markDirty(false);
+ viewport.markForceDirty(false);
+ const dirty = vi.spyOn(viewport.getScrollBar()!, 'makeDirty');
+ const notified = vi.fn();
+ const subscription = viewport.onScrollAfter$.subscribeEvent(notified);
+
+ viewport.scrollToViewportPos({ viewportScrollX: 0, viewportScrollY: -20 });
+ expect(viewport.viewportScrollY).toBe(0);
+ expect(dirty).not.toHaveBeenCalled();
+ expect(notified).toHaveBeenCalledTimes(1);
+
+ viewport.markForceDirty(true);
+ viewport.scrollToViewportPos({ viewportScrollX: 0, viewportScrollY: -20 });
+ expect(dirty).toHaveBeenCalledExactlyOnceWith(true, true);
+ expect(notified).toHaveBeenCalledTimes(2);
+
+ subscription.unsubscribe();
+ scene.dispose();
+ container.remove();
+ });
+
it('locks out minor cross-axis wheel jitter in viewport scrolling', () => {
const { engine, scene, viewport, container } = createFixture();
viewport.scrollToViewportPos({ viewportScrollX: 20, viewportScrollY: 20 });
@@ -207,7 +385,6 @@ describe('engine scene viewport extra', () => {
expect(viewport.viewportScrollX).toBeGreaterThan(20);
scene.dispose();
- engine.dispose();
container.remove();
});
@@ -231,7 +408,6 @@ describe('engine scene viewport extra', () => {
expect(viewport.viewportScrollY).toBeGreaterThan(20);
scene.dispose();
- engine.dispose();
container.remove();
});
@@ -304,7 +480,6 @@ describe('engine scene viewport extra', () => {
expect(engine.getCanvasElement().parentElement).toBe(container);
scene.dispose();
- engine.dispose();
});
it('preserves engine and layer caches only for a pending scroll render', () => {
@@ -328,13 +503,12 @@ describe('engine scene viewport extra', () => {
expect(renderSpy).toHaveBeenLastCalledWith(undefined, false, undefined);
scene.dispose();
- engine.dispose();
});
it('keeps shared viewport boundary pixels out of incremental scroll copies', () => {
const { engine, scene, viewport } = createFixture();
viewport.setViewportSize({ left: 46, top: 20, width: 260, height: 160 });
- const rowHeaderViewport = new Viewport('viewRowBottom', scene, {
+ const rowHeaderViewport = injector.createInstance(Viewport, 'viewRowBottom', scene, {
left: 0,
top: 20,
width: 47,
@@ -342,7 +516,7 @@ describe('engine scene viewport extra', () => {
active: true,
allowCache: true,
});
- new Viewport('viewColumnRight', scene, {
+ injector.createInstance(Viewport, 'viewColumnRight', scene, {
left: 46,
top: 0,
width: 260,
@@ -375,7 +549,6 @@ describe('engine scene viewport extra', () => {
expect(clearRectSpy.mock.calls).toContainEqual([47, 21, expect.any(Number), copiedOffsetY]);
scene.dispose();
- engine.dispose();
});
it('uses a full render after an after-render observer mutates the engine canvas', () => {
@@ -419,7 +592,6 @@ describe('engine scene viewport extra', () => {
subscription.unsubscribe();
scene.dispose();
- engine.dispose();
});
it('keeps cheap content live during a large scrollbar seek', () => {
@@ -465,7 +637,6 @@ describe('engine scene viewport extra', () => {
expect(renderSpy).toHaveBeenCalledTimes(2);
scene.dispose();
- engine.dispose();
});
it('keeps content live while its render cost stays within the seek budget', () => {
@@ -494,7 +665,6 @@ describe('engine scene viewport extra', () => {
expect(renderSpy).toHaveBeenCalledTimes(2);
scene.dispose();
- engine.dispose();
});
it('keeps expensive content stable until a large scrollbar seek settles', () => {
@@ -527,13 +697,12 @@ describe('engine scene viewport extra', () => {
expect(renderSpy).toHaveBeenCalledTimes(1);
scene.dispose();
- engine.dispose();
});
it('scrolls independent viewport regions for a frozen sheet render', () => {
const { engine, scene, viewport, container } = createFixture();
viewport.setViewportSize({ left: 100, width: 200 });
- const frozenViewport = new Viewport('viewMainLeft', scene, {
+ const frozenViewport = injector.createInstance(Viewport, 'viewMainLeft', scene, {
left: 0,
top: 0,
width: 100,
@@ -563,7 +732,6 @@ describe('engine scene viewport extra', () => {
expect(clearCanvasSpy).not.toHaveBeenCalled();
scene.dispose();
- engine.dispose();
container.remove();
});
@@ -652,7 +820,6 @@ describe('engine scene viewport extra', () => {
scene.detachControl();
scene.dispose();
- engine.dispose();
});
it('uses canvas-relative client coordinates to pick touch targets', () => {
@@ -683,11 +850,12 @@ describe('engine scene viewport extra', () => {
expect(pick).toHaveBeenCalledWith(expect.objectContaining({ x: 18, y: 20 }), DeviceType.Touch);
scene.dispose();
- engine.dispose();
});
it('throws when subscribing clientRect$ without mounting container', () => {
- const engine = new Engine('unit-b', { elementWidth: 1, elementHeight: 1, dpr: 1 });
+ const engine = injector.createChild([[Engine, { useFactory: function createTestInstance() {
+ return injector.createInstance(Engine, 'unit-b', { elementWidth: 1, elementHeight: 1, dpr: 1 });
+ } }]]).get(Engine);
const onError = vi.fn();
engine.clientRect$.subscribe({
error: onError,
@@ -697,11 +865,12 @@ describe('engine scene viewport extra', () => {
message: '[Engine]: cannot subscribe to rect changes when container is not set!',
})
);
- engine.dispose();
});
it('estimates the display frame interval without following isolated long frames', () => {
- const engine = new Engine('unit-frame-interval', { elementWidth: 1, elementHeight: 1, dpr: 1 });
+ const engine = injector.createChild([[Engine, { useFactory: function createTestInstance() {
+ return injector.createInstance(Engine, 'unit-frame-interval', { elementWidth: 1, elementHeight: 1, dpr: 1 });
+ } }]]).get(Engine);
let timestamp = 0;
engine._endFrame(timestamp);
for (const interval of [8, 8, 8, 16]) {
@@ -710,7 +879,6 @@ describe('engine scene viewport extra', () => {
}
expect(engine.getEstimatedFrameInterval()).toBe(8);
- engine.dispose();
});
it('covers scene/viewport utility and early-return branches', () => {
@@ -729,7 +897,7 @@ describe('engine scene viewport extra', () => {
expect(scene.getLayerMaxZIndex()).toBeGreaterThanOrEqual(1);
expect(scene.findLayerByZIndex(999)).toBeUndefined();
- const extraRect = new Rect('rect-extra', {
+ const extraRect = injector.createInstance(Rect, 'rect-extra', {
left: 1,
top: 1,
width: 5,
@@ -746,13 +914,13 @@ describe('engine scene viewport extra', () => {
expect(scene.removeObject('rect-extra')).toBe(scene);
expect(scene.removeObjects(['rect-main'] as any)).toBe(scene);
- const orphan = new Rect('orphan', { left: 0, top: 0, width: 2, height: 2 });
+ const orphan = injector.createInstance(Rect, 'orphan', { left: 0, top: 0, width: 2, height: 2 });
const emitSpy = vi.spyOn(orphan.onIsAddedToParent$, 'emitEvent');
scene.setObjectBehavior(orphan);
expect(orphan.parent).toBe(scene);
expect(emitSpy).toHaveBeenCalled();
- const tempViewport = new Viewport('temp-vp', scene, {
+ const tempViewport = injector.createInstance(Viewport, 'temp-vp', scene, {
left: 1,
top: 1,
width: 20,
@@ -807,7 +975,7 @@ describe('engine scene viewport extra', () => {
expect(viewport.scrollByViewportDeltaVal({ viewportScrollX: 1, viewportScrollY: 1 })).toBeUndefined();
viewport.enable();
- const viewportNoScrollBar = new Viewport('temp-vp-2', scene, {
+ const viewportNoScrollBar = injector.createInstance(Viewport, 'temp-vp-2', scene, {
left: 0,
top: 0,
width: 20,
@@ -829,7 +997,6 @@ describe('engine scene viewport extra', () => {
viewportNoScrollBar.dispose();
scene.dispose();
- engine.dispose();
});
it('does not bridge non-overlapping cache bounds when calculating cache diff', () => {
@@ -843,7 +1010,6 @@ describe('engine scene viewport extra', () => {
expect(diffBounds).toEqual([currentBound]);
scene.dispose();
- engine.dispose();
});
it('expands cache diff strips only toward retained cache content', () => {
@@ -893,6 +1059,5 @@ describe('engine scene viewport extra', () => {
]);
scene.dispose();
- engine.dispose();
});
});
diff --git a/packages/engine-render/src/__tests__/layer.spec.ts b/packages/engine-render/src/__tests__/layer.spec.ts
index af36078917..3e976e112d 100644
--- a/packages/engine-render/src/__tests__/layer.spec.ts
+++ b/packages/engine-render/src/__tests__/layer.spec.ts
@@ -14,11 +14,20 @@
* limitations under the License.
*/
+import { Injector } from '@univerjs/core';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
import type { IViewportInfo } from '../basics/vector2';
-import { describe, expect, it, vi } from 'vitest';
import { BaseObject } from '../base-object';
import { RENDER_CLASS_TYPE } from '../basics/const';
+import { Engine } from '../engine';
import { Layer } from '../layer';
+import { MAIN_VIEW_PORT_KEY, Scene } from '../scene';
+import { SceneViewer } from '../scene-viewer';
+import { DumbCanvasColorService, ICanvasColorService } from '../services/canvas-color.service';
+import { Rect } from '../shape/rect';
+import { Viewport } from '../viewport';
+
+let injector: Injector;
class TestObject extends BaseObject {
constructor(id: string, zIndex = 1) {
@@ -46,68 +55,126 @@ class TestGroup extends TestObject {
}
function createScene() {
- let transformCallback: (() => void) | undefined;
- const sceneViewer = {
- classType: RENDER_CLASS_TYPE.SCENE_VIEWER,
- makeDirty: vi.fn(),
- };
- const viewport = {
- viewportKey: 'viewport',
- shouldIntoRender: vi.fn(() => true),
- render: vi.fn(),
- };
- const engine = {
+ injector.add([Engine, {
+ useFactory: function createTestInstance() {
+ return injector.createInstance(Engine, 'layer-engine', { elementWidth: 160, elementHeight: 90, dpr: 1 });
+ },
+ }]);
+ const engine = injector.get(Engine);
+ const rootScene = injector.createInstance(Scene, 'root-layer-scene', engine);
+ const viewer = injector.createInstance(SceneViewer, 'layer-viewer', { width: 320, height: 180 });
+ rootScene.addObject(viewer);
+ const scene = injector.createInstance(Scene, 'layer-scene', viewer);
+ scene.transformByState({ width: 320, height: 180, scaleX: 1, scaleY: 1 });
+ const viewport = injector.createInstance(Viewport, 'viewport', scene, {
+ left: 0,
+ top: 0,
width: 160,
height: 90,
- canvasColorService: undefined,
- onTransformChange$: {
- subscribeEvent: vi.fn((callback: () => void) => {
- transformCallback = callback;
- return { dispose: vi.fn() };
- }),
- },
- };
- const scene = {
- getParent: vi.fn(() => sceneViewer),
- getEngine: vi.fn(() => engine),
- getObject: vi.fn(() => null),
- setObjectBehavior: vi.fn(),
- getViewports: vi.fn(() => [viewport]),
+ active: true,
+ });
+ vi.spyOn(scene, 'setObjectBehavior');
+ vi.spyOn(viewer, 'makeDirty');
+ vi.spyOn(viewport, 'render');
+ return Object.assign(scene, {
__viewport: viewport,
- __sceneViewer: sceneViewer,
- __resizeCache: () => transformCallback?.(),
- };
-
- return scene as any;
+ __sceneViewer: viewer,
+ __resizeCache: () => {
+ engine.resizeBySize(161, 91);
+ engine.resizeBySize(160, 90);
+ },
+ });
}
function createCtx() {
- const canvas = document.createElement('canvas');
- const transform = document.createElement('canvas').getContext('2d')!.getTransform();
- return {
- canvas,
- save: vi.fn(),
- restore: vi.fn(),
- beginPath: vi.fn(),
- rect: vi.fn(),
- clip: vi.fn(),
- clearRect: vi.fn(),
- setTransform: vi.fn(),
- getTransform: vi.fn(() => transform),
- drawImage: vi.fn(),
- } as any;
+ const ctx = injector.get(Engine).getCanvas().getContext();
+ for (const method of ['save', 'restore', 'beginPath', 'rect', 'clip', 'clearRect', 'setTransform', 'getTransform', 'drawImage'] as const) {
+ vi.spyOn(ctx, method);
+ }
+ return ctx;
}
describe('layer', () => {
+ beforeEach(() => {
+ injector = new Injector([[ICanvasColorService, { useClass: DumbCanvasColorService }]]);
+ });
+
+ afterEach(() => injector.dispose());
+
+ it('paints a cache enabled after engine sizing and invalidates it for edits and resize', () => {
+ const injector = new Injector([
+ [ICanvasColorService, { useClass: DumbCanvasColorService }],
+ [Engine, {
+ useFactory: (container: Injector) => container.createInstance(Engine, 'cache-ready', { elementWidth: 160, elementHeight: 90, dpr: 1 }),
+ deps: [Injector],
+ }],
+ [Scene, {
+ useFactory: (container: Injector) => container.createInstance(Scene, 'cache-ready', container.get(Engine)),
+ deps: [Injector],
+ }],
+ [Layer, {
+ useFactory: (container: Injector) => container.createInstance(Layer, container.get(Scene), [], 1),
+ deps: [Injector],
+ }],
+ [Rect, {
+ useFactory: (container: Injector) => container.createInstance(Rect, 'cache-ready', { width: 20, height: 10, fill: '#123456' }),
+ deps: [Injector],
+ }],
+ [Viewport, {
+ useFactory: (container: Injector) => container.createInstance(Viewport, MAIN_VIEW_PORT_KEY, container.get(Scene), { left: 0, top: 0, width: 160, height: 90, active: true }),
+ deps: [Injector],
+ }],
+ ]);
+ const engine = injector.get(Engine);
+ const scene = injector.get(Scene);
+ const layer = injector.get(Layer);
+ const rect = injector.get(Rect);
+ injector.get(Viewport);
+ scene.transformByState({ width: 160, height: 90, scaleX: 1, scaleY: 1 });
+ scene.addLayer(layer);
+ scene.addObject(rect, 1);
+ const context = engine.getCanvas().getContext();
+ const blit = vi.spyOn(context, 'drawImage');
+ const paint = vi.spyOn(rect, 'render');
+ try {
+ layer.enableCache();
+ layer.render(context);
+ expect(blit).toHaveBeenLastCalledWith(expect.any(HTMLCanvasElement), 0, 0, 160, 90);
+ const initialPaints = paint.mock.calls.length;
+ expect(initialPaints).toBeGreaterThan(0);
+ layer.render(context);
+ expect(paint).toHaveBeenCalledTimes(initialPaints);
+
+ rect.setProps({ fill: '#654321' });
+ layer.render(context);
+ expect(paint.mock.calls.length).toBeGreaterThan(initialPaints);
+ engine.resizeBySize(240, 120);
+ layer.render(context);
+ expect(blit).toHaveBeenLastCalledWith(expect.any(HTMLCanvasElement), 0, 0, 240, 120);
+ } finally {
+ paint.mockRestore();
+ blit.mockRestore();
+ injector.dispose();
+ }
+ });
+
it('adds, orders, filters and removes regular objects', () => {
const scene = createScene();
- const visible = new TestObject('visible', 2);
- const hidden = new TestObject('hidden', 1);
- const eventless = new TestObject('eventless', 3);
+ const visible = injector.createChild([[TestObject, { useFactory: function createTestInstance() {
+ return injector.createInstance(TestObject, 'visible', 2);
+ } }]]).get(TestObject);
+ const hidden = injector.createChild([[TestObject, { useFactory: function createTestInstance() {
+ return injector.createInstance(TestObject, 'hidden', 1);
+ } }]]).get(TestObject);
+ const eventless = injector.createChild([[TestObject, { useFactory: function createTestInstance() {
+ return injector.createInstance(TestObject, 'eventless', 3);
+ } }]]).get(TestObject);
hidden.hide();
eventless.evented = false;
- const layer = new Layer(scene, [visible, hidden, eventless], 4);
+ const layer = injector.createChild([[Layer, { useFactory: function createTestInstance() {
+ return injector.createInstance(Layer, scene, [visible, hidden, eventless], 4);
+ } }]]).get(Layer);
expect(layer.scene).toBe(scene);
expect(layer.zIndex).toBe(4);
@@ -128,11 +195,19 @@ describe('layer', () => {
it('expands groups, renders through viewports and updates dirty state', async () => {
const scene = createScene();
- const child = new TestObject('child', 1);
- const duplicateChild = new TestObject('duplicate-child', 2);
- scene.getObject = vi.fn((key: string) => key === 'duplicate-child' ? duplicateChild : null);
- const group = new TestGroup('group', [child, duplicateChild]);
- const layer = new Layer(scene, [], 1);
+ const child = injector.createChild([[TestObject, { useFactory: function createTestInstance() {
+ return injector.createInstance(TestObject, 'child', 1);
+ } }]]).get(TestObject);
+ const duplicateChild = injector.createChild([[TestObject, { useFactory: function createTestInstance() {
+ return injector.createInstance(TestObject, 'duplicate-child', 2);
+ } }]]).get(TestObject);
+ scene.addObject(duplicateChild, 2);
+ const group = injector.createChild([[TestGroup, { useFactory: function createTestInstance() {
+ return injector.createInstance(TestGroup, 'group', [child, duplicateChild]);
+ } }]]).get(TestGroup);
+ const layer = injector.createChild([[Layer, { useFactory: function createTestInstance() {
+ return injector.createInstance(Layer, scene, [], 1);
+ } }]]).get(Layer);
layer.addObject(group);
expect(layer.getObjects().map((object) => object.oKey)).toEqual(['child', 'group']);
@@ -159,10 +234,14 @@ describe('layer', () => {
it('clips scroll repaint and refreshes the stale layer cache before reuse', () => {
const scene = createScene();
- const object = new TestObject('cached', 1);
- const layer = new Layer(scene, [object], 1, true);
+ const object = injector.createChild([[TestObject, { useFactory: function createTestInstance() {
+ return injector.createInstance(TestObject, 'cached', 1);
+ } }]]).get(TestObject);
+ const layer = injector.createChild([[Layer, { useFactory: function createTestInstance() {
+ return injector.createInstance(Layer, scene, [object], 1, true);
+ } }]]).get(Layer);
const ctx = createCtx();
- const viewportInfo = { viewportKey: 'viewport' } as IViewportInfo;
+ const viewportInfo = scene.__viewport.calcViewportInfo();
const dirtyBounds = [{ left: 140, top: 0, right: 160, bottom: 90 }];
scene.__resizeCache();
@@ -175,7 +254,7 @@ describe('layer', () => {
expect(ctx.rect).toHaveBeenCalledWith(140, 0, 20, 90);
expect(ctx.drawImage).not.toHaveBeenCalled();
- scene.__viewport.render.mockClear();
+ vi.mocked(scene.__viewport.render).mockClear();
layer.render(ctx);
expect(scene.__viewport.render).toHaveBeenCalledWith(expect.anything(), [object], false, undefined);
expect(ctx.drawImage).toHaveBeenCalledWith(expect.any(HTMLCanvasElement), 0, 0, 160, 90);
@@ -185,13 +264,17 @@ describe('layer', () => {
it('uses cache canvas rendering, resizing and disposal paths', () => {
const scene = createScene();
- const object = new TestObject('cached', 1);
- const layer = new Layer(scene, [object], 1, true);
+ const object = injector.createChild([[TestObject, { useFactory: function createTestInstance() {
+ return injector.createInstance(TestObject, 'cached', 1);
+ } }]]).get(TestObject);
+ const layer = injector.createChild([[Layer, { useFactory: function createTestInstance() {
+ return injector.createInstance(Layer, scene, [object], 1, true);
+ } }]]).get(Layer);
const ctx = createCtx();
expect(layer.isAllowCache()).toBe(true);
layer.render(ctx);
- expect(ctx.drawImage).not.toHaveBeenCalled();
+ expect(ctx.drawImage).toHaveBeenCalledWith(expect.any(HTMLCanvasElement), 0, 0, 160, 90);
scene.__resizeCache();
layer.render(ctx);
diff --git a/packages/engine-render/src/base-object.ts b/packages/engine-render/src/base-object.ts
index 039450c2e8..ed26240d80 100644
--- a/packages/engine-render/src/base-object.ts
+++ b/packages/engine-render/src/base-object.ts
@@ -407,6 +407,15 @@ export abstract class BaseObject extends Disposable {
return this._zIndex;
}
+ /** Opt in only when pixels depend on invalidated render state, not animation or external callbacks. */
+ viewportCacheReusable = false;
+
+ canReuseViewportCache(): boolean {
+ return this.viewportCacheReusable;
+ }
+
+ onViewportCacheReuse(_viewportInfo: IViewportInfo): void {}
+
makeDirty(state: boolean = true) {
this._dirty = state;
@@ -422,6 +431,10 @@ export abstract class BaseObject extends Disposable {
return this;
}
+ isForceDirty(): boolean {
+ return this._forceDirty;
+ }
+
makeForceDirty(state: boolean = true) {
this._forceDirty = state;
}
diff --git a/packages/engine-render/src/basics/__tests__/draw.spec.ts b/packages/engine-render/src/basics/__tests__/draw.spec.ts
index c0afb09c06..a59207ec04 100644
--- a/packages/engine-render/src/basics/__tests__/draw.spec.ts
+++ b/packages/engine-render/src/basics/__tests__/draw.spec.ts
@@ -152,3 +152,13 @@ describe('draw extra', () => {
});
});
});
+
+describe('solid line transitions', () => {
+ it.each([BorderStyleTypes.THIN, BorderStyleTypes.MEDIUM, BorderStyleTypes.THICK, BorderStyleTypes.DOUBLE])('clears the preceding dash pattern for solid style %s', (style) => {
+ const ctx = createCtxMock();
+ setLineType(ctx, BorderStyleTypes.DASHED);
+ expect(ctx.setLineDash).toHaveBeenLastCalledWith([3]);
+ setLineType(ctx, style);
+ expect(ctx.setLineDash).toHaveBeenLastCalledWith([]);
+ });
+});
diff --git a/packages/engine-render/src/basics/draw.ts b/packages/engine-render/src/basics/draw.ts
index 0127d362f0..7d55a483d9 100644
--- a/packages/engine-render/src/basics/draw.ts
+++ b/packages/engine-render/src/basics/draw.ts
@@ -15,9 +15,9 @@
*/
import type { IPosition } from '@univerjs/core';
+import { BorderStyleTypes } from '@univerjs/core';
import type { UniverRenderingContext } from '../context';
import type { IDocumentSkeletonLine } from './i-document-skeleton-cached';
-import { BorderStyleTypes } from '@univerjs/core';
import { BORDER_TYPE, ORIENTATION_TYPE } from './const';
import { createCanvasElement } from './tools';
import { Vector2 } from './vector2';
@@ -264,7 +264,8 @@ export function setLineType(ctx: UniverRenderingContext, style: BorderStyleTypes
} else if (style === BorderStyleTypes.DASHED || style === BorderStyleTypes.MEDIUM_DASHED) {
ctx.setLineDash([3]);
} else {
- ctx.setLineDash([0]);
+ // WebKit retains the preceding dash pattern when given an all-zero list.
+ ctx.setLineDash([]);
}
}
diff --git a/packages/engine-render/src/components/__tests__/component.spec.ts b/packages/engine-render/src/components/__tests__/component.spec.ts
new file mode 100644
index 0000000000..364d01dc99
--- /dev/null
+++ b/packages/engine-render/src/components/__tests__/component.spec.ts
@@ -0,0 +1,136 @@
+/**
+ * Copyright 2023-present DreamNum Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import type { IRange } from '@univerjs/core';
+import { Injector } from '@univerjs/core';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import type { SHEET_EXTENSION_TYPE } from '../sheets/extensions/sheet-extension';
+import type { SpreadsheetSkeleton } from '../sheets/sheet.render-skeleton';
+import { RenderComponent } from '../component';
+import { ComponentExtension } from '../extension';
+import { Font } from '../sheets/extensions/font';
+
+let injector: Injector;
+
+describe('RenderComponent', () => {
+ beforeEach(() => {
+ injector = new Injector([[Font]]);
+ });
+
+ afterEach(() => injector.dispose());
+
+ afterEach(() => {
+ vi.restoreAllMocks();
+ vi.unstubAllGlobals();
+ });
+
+ it('consults current extension eligibility instead of its static opt-in flag', () => {
+ class ConditionalExtension extends ComponentExtension<unknown, string, unknown> {
+ override viewportCacheReusable = true;
+ enabled = false;
+
+ override canReuseViewportCache(): boolean {
+ return super.canReuseViewportCache() && this.enabled;
+ }
+ }
+ const component = injector.createChild([[RenderComponent, { useFactory: function createTestInstance() {
+ return injector.createInstance(RenderComponent<unknown, string, unknown>, 'conditional-component');
+ } }]]).get(RenderComponent<unknown, string, unknown>);
+ const extension = injector.createChild([[ConditionalExtension, { useFactory: function createTestInstance() {
+ return injector.createInstance(ConditionalExtension);
+ } }]]).get(ConditionalExtension);
+ component.viewportCacheReusable = true;
+ component.register(extension);
+ try {
+ expect(component.canReuseViewportCache()).toBe(false);
+ extension.enabled = true;
+ expect(component.canReuseViewportCache()).toBe(true);
+ extension.enabled = false;
+ expect(component.canReuseViewportCache()).toBe(false);
+ } finally {
+ component.dispose();
+ }
+ });
+
+ it.each([undefined, true])('keeps flag-only extensions without a callable eligibility method on the full path (%s)', (method) => {
+ const component = injector.createChild([[RenderComponent, { useFactory: function createTestInstance() {
+ return injector.createInstance(RenderComponent<unknown, string, unknown>, 'legacy-component');
+ } }]]).get(RenderComponent<unknown, string, unknown>);
+ component.viewportCacheReusable = true;
+ component.register({
+ uKey: 'legacy-extension',
+ viewportCacheReusable: true,
+ canReuseViewportCache: method,
+ dispose: vi.fn(),
+ } as unknown as ComponentExtension<unknown, string, unknown>);
+ try {
+ expect(component.canReuseViewportCache()).toBe(false);
+ } finally {
+ component.dispose();
+ }
+ });
+
+ it('does not inherit built-in cache eligibility through an unknown replacement subclass', () => {
+ class UnknownFont extends Font {}
+ const component = injector.createChild([[RenderComponent, { useFactory: function createTestInstance() {
+ return injector.createInstance(RenderComponent<SpreadsheetSkeleton, SHEET_EXTENSION_TYPE, IRange[]>, 'replacement-component');
+ } }]]).get(RenderComponent<SpreadsheetSkeleton, SHEET_EXTENSION_TYPE, IRange[]>);
+ component.viewportCacheReusable = true;
+ const known = injector.get(Font);
+ component.register(known);
+ try {
+ expect(component.canReuseViewportCache()).toBe(true);
+ component.register(injector.createChild([[UnknownFont, { useFactory: function createTestInstance() {
+ return injector.createInstance(UnknownFont);
+ } }]]).get(UnknownFont));
+ expect(component.canReuseViewportCache()).toBe(false);
+ } finally {
+ component.dispose();
+ known.dispose();
+ }
+ });
+
+ it.each([false, true])('disposes owned extensions once and disconnects image loads (loaded: %s)', (loaded) => {
+ const image = document.createElement('img');
+ vi.stubGlobal('Image', vi.fn(function () {
+ return image;
+ }));
+ const component = injector.createChild([[RenderComponent, { useFactory: function createTestInstance() {
+ return injector.createInstance(RenderComponent<SpreadsheetSkeleton, SHEET_EXTENSION_TYPE, IRange[]>, 'component');
+ } }]]).get(RenderComponent<SpreadsheetSkeleton, SHEET_EXTENSION_TYPE, IRange[]>);
+ const extension = injector.get(Font);
+ const dispose = vi.spyOn(extension, 'dispose');
+ const dirty = vi.spyOn(component, 'makeDirty');
+ component.register(extension);
+ if (loaded) {
+ image.dispatchEvent(new Event('load'));
+ expect(dirty).toHaveBeenCalledExactlyOnceWith(true);
+ dirty.mockClear();
+ }
+
+ component.dispose();
+ expect(dispose).toHaveBeenCalledOnce();
+ expect(component.extensions.size).toBe(0);
+ expect(extension.parent).toBeNull();
+ expect(image.onload).toBeNull();
+ dirty.mockClear();
+ image.dispatchEvent(new Event('load'));
+ expect(dirty).not.toHaveBeenCalled();
+
+ component.dispose();
+ expect(dispose).toHaveBeenCalledOnce();
+ });
+});
diff --git a/packages/engine-render/src/components/__tests__/extension.spec.ts b/packages/engine-render/src/components/__tests__/extension.spec.ts
index ac756c9d47..633ec899a8 100644
--- a/packages/engine-render/src/components/__tests__/extension.spec.ts
+++ b/packages/engine-render/src/components/__tests__/extension.spec.ts
@@ -15,9 +15,12 @@
*/
import type { IScale } from '@univerjs/core';
-import { describe, expect, it } from 'vitest';
+import { Injector } from '@univerjs/core';
+import { afterEach, beforeEach, describe, expect, it } from 'vitest';
import { ComponentExtension } from '../extension';
+let injector: Injector;
+
class TestExtension extends ComponentExtension<unknown, string, unknown> {
constructor() {
super();
@@ -31,15 +34,30 @@ class TestExtension extends ComponentExtension<unknown, string, unknown> {
}
describe('ComponentExtension', () => {
+ beforeEach(() => {
+ injector = new Injector([[TestExtension]]);
+ });
+
+ afterEach(() => injector.dispose());
+
+ it('requires an explicit viewport cache opt-in', () => {
+ const extension = injector.get(TestExtension);
+ expect(extension.canReuseViewportCache()).toBe(false);
+ extension.viewportCacheReusable = true;
+ expect(extension.canReuseViewportCache()).toBe(true);
+ extension.viewportCacheReusable = false;
+ expect(extension.canReuseViewportCache()).toBe(false);
+ });
+
it('uses the larger parent scale for extension rendering math', () => {
- const extension = new TestExtension();
+ const extension = injector.get(TestExtension);
expect(extension.getParentScale({ scaleX: 1.25, scaleY: 2 })).toBe(2);
expect(extension.getParentScale({})).toBe(1);
});
it('clears transient render offsets and parent links on dispose', () => {
- const extension = new TestExtension();
+ const extension = injector.get(TestExtension);
extension.parent = {} as never;
extension.extensionOffset = {
renderConfig: {},
diff --git a/packages/engine-render/src/components/component.ts b/packages/engine-render/src/components/component.ts
index d7c10ca610..60d450adfc 100644
--- a/packages/engine-render/src/components/component.ts
+++ b/packages/engine-render/src/components/component.ts
@@ -15,15 +15,21 @@
*/
import type { IDisposable } from '@univerjs/core';
+import { DisposableCollection, sortRules, toDisposable } from '@univerjs/core';
import type { IViewportInfo } from '../basics/vector2';
import type { UniverRenderingContext } from '../context';
import type { ComponentExtension } from './extension';
-import { DisposableCollection, sortRules, toDisposable } from '@univerjs/core';
import { BaseObject } from '../base-object';
export class RenderComponent<T, U, V> extends BaseObject {
private _extensions = new Map<string, ComponentExtension<T, U, V>>();
+ override canReuseViewportCache(): boolean {
+ return super.canReuseViewportCache() && this.getExtensionsByOrder().every((extension) =>
+ typeof extension.canReuseViewportCache === 'function' && extension.canReuseViewportCache() === true
+ );
+ }
+
get extensions() {
return this._extensions;
}
@@ -33,10 +39,14 @@ export class RenderComponent<T, U, V> extends BaseObject {
for (const extension of extensions) {
extension.parent = this;
this._extensions.set(extension.uKey, extension);
+ this.makeForceDirty(true);
+ this.makeDirtyNoDebounce(true);
disposableCollection.add(
toDisposable(() => {
this._extensions.delete(extension.uKey);
+ this.makeForceDirty(true);
+ this.makeDirtyNoDebounce(true);
extension.parent = null;
})
);
@@ -63,9 +73,10 @@ export class RenderComponent<T, U, V> extends BaseObject {
}
override dispose(): void {
+ const extensions = [...this._extensions.values()];
super.dispose();
- for (const extension of this._extensions.values()) {
+ for (const extension of extensions) {
extension.dispose();
}
diff --git a/packages/engine-render/src/components/docs/layout/shaping-engine/font-cache.ts b/packages/engine-render/src/components/docs/layout/shaping-engine/font-cache.ts
index 56409fa805..c25c38ad83 100644
--- a/packages/engine-render/src/components/docs/layout/shaping-engine/font-cache.ts
+++ b/packages/engine-render/src/components/docs/layout/shaping-engine/font-cache.ts
@@ -78,11 +78,18 @@ export class FontCache {
private static _globalFontMeasureCache: Map<string, Map<string, IMeasureTextCache>> = new Map();
+ private static _metricsRevision = 0;
+
+ static get metricsRevision(): number {
+ return this._metricsRevision;
+ }
+
static get globalFontMeasureCache() {
return this._globalFontMeasureCache;
}
static invalidateMetrics(matches: (fontStyle: string) => boolean): boolean {
+ this._metricsRevision++;
let changed = false;
const keys = new Set([
...this._globalFontMeasureCache.keys(),
@@ -124,6 +131,7 @@ export class FontCache {
} else {
return false;
}
+ this._metricsRevision++;
return true;
}
diff --git a/packages/engine-render/src/components/extension.ts b/packages/engine-render/src/components/extension.ts
index 15c8a49c5b..afaa0e3779 100644
--- a/packages/engine-render/src/components/extension.ts
+++ b/packages/engine-render/src/components/extension.ts
@@ -15,11 +15,11 @@
*/
import type { IRange, IScale, Nullable } from '@univerjs/core';
+import { Registry } from '@univerjs/core';
import type { BaseObject } from '../base-object';
import type { IBoundRectNoAngle, Vector2 } from '../basics/vector2';
import type { UniverRenderingContext } from '../context';
import type { IDocumentLayoutRenderConfig } from './docs/document-layout-presentation';
-import { Registry } from '@univerjs/core';
import { getScale } from '../basics/tools';
export interface IExtensionConfig {
@@ -38,10 +38,14 @@ export interface IDrawInfo {
fontRenderRanges?: IRange[];
hasMergeData?: boolean;
viewBound?: IBoundRectNoAngle;
+ /** Physical-pixel damage clip, before any extension-specific clipping. */
+ textClipBound?: IBoundRectNoAngle;
}
export class ComponentExtension<T, U, V> {
uKey: string = '';
+ viewportCacheReusable: boolean = false;
+
type!: U;
protected Z_INDEX: number = 0;
@@ -58,6 +62,10 @@ export class ComponentExtension<T, U, V> {
return this.Z_INDEX;
}
+ canReuseViewportCache(): boolean {
+ return this.viewportCacheReusable;
+ }
+
draw(_ctx: UniverRenderingContext, _parentScale: IScale, _skeleton: T, _diff?: V, _more?: IDrawInfo) {
/* abstract */
}
diff --git a/packages/engine-render/src/components/sheets/__tests__/sheet-header-util.spec.ts b/packages/engine-render/src/components/sheets/__tests__/sheet-header-util.spec.ts
index ab26424a51..3b19dbc3e1 100644
--- a/packages/engine-render/src/components/sheets/__tests__/sheet-header-util.spec.ts
+++ b/packages/engine-render/src/components/sheets/__tests__/sheet-header-util.spec.ts
@@ -15,7 +15,6 @@
*/
import type { IWorkbookData, Workbook } from '@univerjs/core';
-import type { IBoundRectNoAngle, IViewportInfo } from '../../../basics/vector2';
import {
CellValueType,
HorizontalAlign,
@@ -29,6 +28,7 @@ import {
WrapStrategy,
} from '@univerjs/core';
import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import type { IBoundRectNoAngle, IViewportInfo } from '../../../basics/vector2';
import { setupRenderTestEnv } from '../../../__tests__/render-test-utils';
import { Vector2 } from '../../../basics/vector2';
import { Canvas } from '../../../canvas';
diff --git a/packages/engine-render/src/components/sheets/__tests__/sheet.render-skeleton.spec.ts b/packages/engine-render/src/components/sheets/__tests__/sheet.render-skeleton.spec.ts
index 1f6766744c..f57cce53ef 100644
--- a/packages/engine-render/src/components/sheets/__tests__/sheet.render-skeleton.spec.ts
+++ b/packages/engine-render/src/components/sheets/__tests__/sheet.render-skeleton.spec.ts
@@ -14,7 +14,7 @@
* limitations under the License.
*/
-import type { IWorkbookData, Workbook } from '@univerjs/core';
+import type { ICellData, IWorkbookData, ObjectMatrix, Workbook } from '@univerjs/core';
import {
BooleanNumber,
BorderStyleTypes,
@@ -32,14 +32,140 @@ import {
WrapStrategy,
} from '@univerjs/core';
import { afterEach, describe, expect, it, vi } from 'vitest';
+import type { IViewportInfo } from '../../../basics/vector2';
import { setupRenderTestEnv } from '../../../__tests__/render-test-utils';
import { BORDER_TYPE } from '../../../basics/const';
import { DocSimpleSkeleton } from '../../docs/layout/doc-simple-skeleton';
import { DocumentSkeleton } from '../../docs/layout/doc-skeleton';
import { FontCache } from '../../docs/layout/shaping-engine/font-cache';
import { DocumentViewModel } from '../../docs/view-model/document-view-model';
+import { Font } from '../extensions/font';
import { getCustomNumberDisplayText, getDocsSkeletonPageSize, getGeneralNumberDisplayText, SpreadsheetSkeleton } from '../sheet.render-skeleton';
+describe('Scroll cache history', () => {
+ it.each([false, true])('keeps unstyled empty cells sparse after a disjoint 10,000-row scan (stored empty cells: %s)', (stored) => {
+ const environment = setupRenderTestEnv();
+ const univer = new Univer({ locale: LocaleType.EN_US });
+ const injector = univer.__getInjector();
+ const workbook = univer.createUnit<IWorkbookData, Workbook>(UniverInstanceType.UNIVER_SHEET, {
+ id: 'empty-scroll-cache',
+ sheetOrder: ['sheet'],
+ sheets: { sheet: {
+ id: 'sheet',
+ rowCount: 10_000,
+ columnCount: 20,
+ defaultRowHeight: 20,
+ defaultColumnWidth: 100,
+ cellData: stored ? Object.fromEntries(Array.from({ length: 10_000 }, (_, row) => [row, { 0: {} }])) : {},
+ } },
+ });
+ injector.add([SpreadsheetSkeleton, {
+ useFactory: () => injector.createInstance(SpreadsheetSkeleton, workbook.getActiveSheet()!, workbook.getStyles()),
+ }]);
+ const skeleton = injector.get(SpreadsheetSkeleton);
+ const prepare = (row: number) => {
+ const bound = {
+ left: skeleton.rowHeaderWidthAndMarginLeft,
+ right: skeleton.rowHeaderWidthAndMarginLeft + 2000,
+ top: skeleton.columnHeaderHeightAndMarginTop + row * 20,
+ bottom: skeleton.columnHeaderHeightAndMarginTop + (row + 20) * 20,
+ };
+ skeleton.setStylesCache({
+ viewBound: bound,
+ cacheBound: bound,
+ viewportKey: 'viewMain',
+ isDirty: 0,
+ isForceDirty: false,
+ shouldCacheUpdate: 1,
+ diffX: 0,
+ diffY: 400,
+ diffBounds: [bound],
+ diffCacheBounds: [bound],
+ } as IViewportInfo, { scaleY: 1 });
+ };
+ const expectSparse = () => {
+ for (const key of ['_handleBgMatrix', '_handleBorderMatrix', '_emptyFontCache']) {
+ const matrix: ObjectMatrix<unknown> = Reflect.get(skeleton, key);
+ let entries = 0;
+ matrix.forValue(() => {
+ entries++;
+ });
+ expect(entries, key).toBe(0);
+ }
+ };
+ try {
+ skeleton.calculate();
+ for (let row = 0; row < 10_000; row += 20) {
+ prepare(row);
+ }
+ expectSparse();
+ prepare(0);
+ expectSparse();
+ skeleton.resetRangeCache([{ startRow: 0, endRow: 0, startColumn: 0, endColumn: 0 }]);
+ expectSparse();
+ } finally {
+ univer.dispose();
+ environment.restore();
+ }
+ });
+
+ it('finds native clip candidates without scanning retained plain text and invalidates them with the font cache', () => {
+ const environment = setupRenderTestEnv();
+ const univer = new Univer({ locale: LocaleType.EN_US });
+ const injector = univer.__getInjector();
+ const cells: Record<number, Record<number, ICellData>> = Object.fromEntries(
+ Array.from({ length: 10_000 }, (_, row) => [row, { 0: { v: `row ${row}` } }])
+ );
+ cells[0][1] = { v: 'merged rotation', s: { tr: { a: 45 } } };
+ cells[5000][1] = { v: 'stacked', s: { tr: { a: 0, v: BooleanNumber.TRUE } } };
+ cells[9999][1] = { v: 'shrink this long text to fit'.repeat(20), s: { stf: BooleanNumber.TRUE } };
+ const merge = { startRow: 0, endRow: 40, startColumn: 1, endColumn: 2 };
+ const workbook = univer.createUnit<IWorkbookData, Workbook>(UniverInstanceType.UNIVER_SHEET, {
+ id: 'native-clip-history',
+ sheetOrder: ['sheet'],
+ sheets: { sheet: {
+ id: 'sheet',
+ rowCount: 10_000,
+ columnCount: 3,
+ defaultRowHeight: 20,
+ defaultColumnWidth: 40,
+ cellData: cells,
+ mergeData: [merge],
+ } },
+ });
+ injector.add([SpreadsheetSkeleton, {
+ useFactory: () => injector.createInstance(SpreadsheetSkeleton, workbook.getActiveSheet()!, workbook.getStyles()),
+ }]);
+ injector.add([Font]);
+ const skeleton = injector.get(SpreadsheetSkeleton);
+ const font = injector.get(Font);
+ try {
+ skeleton.calculate();
+ for (let row = 0; row < 10_000; row++) {
+ for (const column of Object.keys(cells[row]).map(Number)) {
+ skeleton._setFontStylesCache(row, column, cells[row][column], skeleton.worksheet.getComposedCellStyle(row, column));
+ }
+ }
+ const history = vi.spyOn(skeleton.stylesCache.fontMatrix, 'forValue');
+ expect(font.getNativeTextClipRepairRanges(skeleton)).toEqual([
+ merge,
+ { startRow: 5000, endRow: 5000, startColumn: 1, endColumn: 1 },
+ { startRow: 9999, endRow: 9999, startColumn: 1, endColumn: 2 },
+ ]);
+ expect(history).not.toHaveBeenCalled();
+ skeleton.resetRangeCache([merge]);
+ expect(font.getNativeTextClipRepairRanges(skeleton)).toHaveLength(2);
+ skeleton.resetCache();
+ expect(font.getNativeTextClipRepairRanges(skeleton)).toEqual([]);
+ skeleton.dispose();
+ expect(font.getNativeTextClipRepairRanges(skeleton)).toEqual([]);
+ } finally {
+ univer.dispose();
+ environment.restore();
+ }
+ });
+});
+
describe('Rich-text render snapshot isolation', () => {
it.each(['font cache', 'row height', 'column width'])(
'does not rewrite persisted rich text while calculating %s',
diff --git a/packages/engine-render/src/components/sheets/__tests__/spreadsheet.apply-cache.spec.ts b/packages/engine-render/src/components/sheets/__tests__/spreadsheet.apply-cache.spec.ts
index 31c99eb0e2..89fd470dc4 100644
--- a/packages/engine-render/src/components/sheets/__tests__/spreadsheet.apply-cache.spec.ts
+++ b/packages/engine-render/src/components/sheets/__tests__/spreadsheet.apply-cache.spec.ts
@@ -14,12 +14,26 @@
* limitations under the License.
*/
+import { Injector } from '@univerjs/core';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
import type { Canvas } from '../../../canvas';
import type { UniverRenderingContext2D } from '../../../context';
-import { describe, expect, it, vi } from 'vitest';
+import { UniverRenderingContext } from '../../../context';
import { Spreadsheet } from '../spreadsheet';
+let injector: Injector;
+beforeEach(() => {
+ injector = new Injector();
+});
+afterEach(() => injector.dispose());
+
+function createSpreadsheet(key: string): Spreadsheet {
+ injector.add([Spreadsheet, { useFactory: () => injector.createInstance(Spreadsheet, key) }]);
+ return injector.get(Spreadsheet);
+}
+
interface ISpreadsheetApplyCache {
+ _repairGridlineStroke: (ctx: UniverRenderingContext2D, left: number, top: number, right: number, bottom: number, rectangle?: boolean) => void;
_applyCache: (
cacheCanvas: Canvas,
ctx: UniverRenderingContext2D,
@@ -62,7 +76,7 @@ function callApplyCache(
ctx: ReturnType<typeof createMockCtx>,
...rect: [number, number, number, number, number, number, number, number]
) {
- const spreadsheet = new Spreadsheet('sheet-apply-cache-test');
+ const spreadsheet = createSpreadsheet('sheet-apply-cache-test');
(spreadsheet as unknown as ISpreadsheetApplyCache)._applyCache(
cacheCanvas as unknown as Canvas,
ctx as unknown as UniverRenderingContext2D,
@@ -182,3 +196,65 @@ describe('spreadsheet _applyCache blit clipping', () => {
);
});
});
+
+describe('spreadsheet native cache gridline interiors', () => {
+ it.each(['opaque', 'alpha', 'translucent', 'fractional', 'shadow', 'dash', 'filter', 'color-space'])('preserves native corners, style composition and texture bounds for %s', (mode) => {
+ const spreadsheet = createSpreadsheet('native-grid-test');
+ const native = document.createElement('canvas').getContext('2d')!;
+ const ctx = injector.createInstance(UniverRenderingContext, native);
+ ctx.setTransform(1.5, 0, 0, 1.5, mode === 'fractional' ? 0.51 : 0.5, mode === 'fractional' ? 0.51 : 0.5);
+ ctx.lineWidth = 2 / 3;
+ native.strokeStyle = mode === 'translucent' ? 'rgba(29,78,216,0.5)' : '#1d4ed8';
+ native.fillStyle = '#be123c';
+ if (mode === 'alpha') {
+ native.globalAlpha = 0.5;
+ }
+ if (mode === 'shadow') {
+ native.shadowBlur = 2;
+ }
+ if (mode === 'dash') {
+ native.setLineDash([2, 2]);
+ }
+ if (mode === 'filter') {
+ native.filter = 'blur(2px)';
+ }
+ if (mode === 'color-space') {
+ Object.defineProperty(native, 'getContextAttributes', { value: () => ({ colorSpace: 'display-p3' }) });
+ }
+ const fill = vi.spyOn(native, 'fillRect');
+ const allocation = vi.spyOn(document, 'createElement');
+ try {
+ (spreadsheet as unknown as ISpreadsheetApplyCache)._repairGridlineStroke(ctx, 10, 20, 10000, 10000, true);
+ expect(fill).toHaveBeenCalledTimes(mode === 'opaque' ? 4 : 0);
+ if (mode === 'opaque') {
+ expect(fill).toHaveBeenNthCalledWith(1, 20, 30, 14976, 1);
+ for (const rect of fill.mock.calls) {
+ expect(rect.every(Number.isInteger)).toBe(true);
+ expect(Math.min(rect[2], rect[3])).toBe(1);
+ }
+ }
+ expect(allocation).not.toHaveBeenCalled();
+ expect(native.fillStyle).toBe('#be123c');
+ expect(native.getTransform()).toMatchObject({ a: 1.5, d: 1.5, e: mode === 'fractional' ? 0.51 : 0.5 });
+ } finally {
+ allocation.mockRestore();
+ spreadsheet.dispose();
+ }
+ });
+
+ it('restores native drawing state when an interior repair throws', () => {
+ const spreadsheet = createSpreadsheet('native-grid-error');
+ const native = document.createElement('canvas').getContext('2d')!;
+ const ctx = injector.createInstance(UniverRenderingContext, native);
+ ctx.setTransform(1, 0, 0, 1, 0.5, 0.5);
+ native.strokeStyle = '#1d4ed8';
+ native.fillStyle = '#be123c';
+ vi.spyOn(native, 'fillRect').mockImplementation(() => {
+ throw new Error('failed repair');
+ });
+ expect(() => (spreadsheet as unknown as ISpreadsheetApplyCache)._repairGridlineStroke(ctx, 10, 20, 100, 100)).toThrow('failed repair');
+ expect(native.fillStyle).toBe('#be123c');
+ expect(native.getTransform()).toMatchObject({ a: 1, d: 1, e: 0.5, f: 0.5 });
+ spreadsheet.dispose();
+ });
+});
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 acb2b868bc..d64be0a6fc 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
@@ -14,39 +14,42 @@
* limitations under the License.
*/
-import type { IDocumentData, IWorkbookData, Workbook } from '@univerjs/core';
-import type { IBoundRectNoAngle, IViewportInfo } from '../../../basics/vector2';
+import type { ICellDataForSheetInterceptor, IDocumentData, IStyleData, IWorkbookData, Workbook } from '@univerjs/core';
import {
BooleanNumber,
BorderStyleTypes,
createSheetGapTestConfig,
CustomRangeType,
HorizontalAlign,
-
ILogService,
+ Injector,
IUniverInstanceService,
-
LocaleType,
LogLevel,
ObjectMatrix,
RANGE_TYPE,
ThemeService,
+ Tools,
Univer,
UniverInstanceType,
VerticalAlign,
-
WrapStrategy,
} from '@univerjs/core';
import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import type { IBoundRectNoAngle, IViewportInfo } from '../../../basics/vector2';
import { setupRenderTestEnv } from '../../../__tests__/render-test-utils';
-import { FontCache } from '../../../basics';
import { Vector2 } from '../../../basics/vector2';
import { Canvas } from '../../../canvas';
import { Engine } from '../../../engine';
import { MAIN_VIEW_PORT_KEY, Scene } from '../../../scene';
+import { DumbCanvasColorService, ICanvasColorService } from '../../../services/canvas-color.service';
import { Viewport } from '../../../viewport';
+import { FontCache } from '../../docs/layout/shaping-engine/font-cache';
+import { Background } from '../extensions/background';
+import { Border } from '../extensions/border';
import { Font } from '../extensions/font';
-import { SHEET_EXTENSION_TYPE } from '../extensions/sheet-extension';
+import { Marker } from '../extensions/marker';
+import { SHEET_EXTENSION_TYPE, SheetExtension } from '../extensions/sheet-extension';
import { SHEET_VIEWPORT_KEY } from '../interfaces';
import {
convertTransformToOffsetX,
@@ -129,6 +132,7 @@ const workbookDataFactory = (): IWorkbookData => ({
});
interface IFixture {
+ rootInjector: Injector;
univer: Univer;
workbook: Workbook;
skeleton: SpreadsheetSkeleton;
@@ -175,28 +179,32 @@ function createViewportInfo(scene: Scene, cacheCanvas: Canvas, overrides?: Parti
};
}
-function createFixture(): IFixture {
+function createFixture(data: IWorkbookData = workbookDataFactory()): IFixture {
const renderEnv = setupRenderTestEnv();
- const univer = new Univer();
+ const rootInjector = new Injector([[Univer]]);
+ const univer = rootInjector.get(Univer);
const injector = univer.__getInjector();
+ injector.add([ICanvasColorService, { useClass: DumbCanvasColorService }]);
const get = injector.get.bind(injector);
- const workbook = univer.createUnit<IWorkbookData, Workbook>(UniverInstanceType.UNIVER_SHEET, workbookDataFactory());
+ const workbook = univer.createUnit<IWorkbookData, Workbook>(UniverInstanceType.UNIVER_SHEET, data);
get(IUniverInstanceService).focusUnit('sheet-render-workbook');
get(ILogService).setLogLevel(LogLevel.SILENT);
const worksheet = workbook.getActiveSheet()!;
- const skeleton = injector.createInstance(SpreadsheetSkeleton, worksheet, workbook.getStyles()).calculate() as SpreadsheetSkeleton;
+ injector.add([SpreadsheetSkeleton, { useFactory: () => injector.createInstance(SpreadsheetSkeleton, worksheet, workbook.getStyles()) }]);
+ const skeleton = get(SpreadsheetSkeleton);
+ skeleton.calculate();
const container = document.createElement('div');
container.style.width = '640px';
container.style.height = '360px';
document.body.appendChild(container);
- const engine = new Engine('sheet-render-engine', { elementWidth: 620, elementHeight: 340, dpr: 1 });
+ const engine = injector.createInstance(Engine, 'sheet-render-engine', { elementWidth: 620, elementHeight: 340, dpr: 1 });
engine.mount(container, false);
- const scene = new Scene('sheet-render-scene', engine);
+ const scene = injector.createInstance(Scene, 'sheet-render-scene', engine);
scene.transformByState({
width: 1800,
height: 1200,
@@ -204,7 +212,7 @@ function createFixture(): IFixture {
scaleY: 1,
});
- const viewport = new Viewport(MAIN_VIEW_PORT_KEY, scene, {
+ const viewport = injector.createInstance(Viewport, MAIN_VIEW_PORT_KEY, scene, {
left: 0,
top: 0,
width: 420,
@@ -217,13 +225,15 @@ function createFixture(): IFixture {
viewport.scrollToViewportPos({ viewportScrollX: 30, viewportScrollY: 18 });
skeleton.setScene(scene);
- const spreadsheet = new Spreadsheet('sheet-component', skeleton, true);
+ injector.add([Spreadsheet, { useFactory: () => injector.createInstance(Spreadsheet, 'sheet-component', skeleton, true) }]);
+ const spreadsheet = get(Spreadsheet);
scene.addObject(spreadsheet, 1);
- const mainCanvas = new Canvas({ width: 640, height: 360, pixelRatio: 1 });
- const cacheCanvas = new Canvas({ width: 700, height: 420, pixelRatio: 1 });
+ const mainCanvas = injector.createInstance(Canvas, { width: 640, height: 360, pixelRatio: 1 });
+ const cacheCanvas = injector.createInstance(Canvas, { width: 700, height: 420, pixelRatio: 1 });
return {
+ rootInjector,
univer,
workbook,
skeleton,
@@ -245,11 +255,26 @@ function disposeFixture(fixture: IFixture) {
fixture.engine.dispose();
fixture.mainCanvas.dispose();
fixture.cacheCanvas.dispose();
- fixture.univer.dispose();
+ fixture.rootInjector.dispose();
fixture.restoreEnv();
fixture.container.remove();
}
+class RenderOrderProbe extends SheetExtension {
+ drawCount = 0;
+
+ constructor(key: string, zIndex: number, type: SHEET_EXTENSION_TYPE) {
+ super();
+ this.uKey = key;
+ this.Z_INDEX = zIndex;
+ this.type = type;
+ }
+
+ override draw() {
+ this.drawCount++;
+ }
+}
+
describe('spreadsheet integration', () => {
let fixture: IFixture;
@@ -269,6 +294,209 @@ describe('spreadsheet integration', () => {
expect(getShrinkToFitScale(2400, 100, 12)).toBeCloseTo(1 / 12);
});
+ it.each([
+ { system: 'Linux', scale: 1.5, merges: true, overflow: false, hidden: false, disabled: false, expected: true },
+ { system: 'Linux', scale: 1.5, merges: false, overflow: true, hidden: false, disabled: false, expected: true },
+ { system: 'Mac', scale: 1.5, merges: true, overflow: true, hidden: false, disabled: false, expected: false },
+ { system: 'Linux', scale: 2, merges: true, overflow: true, hidden: false, disabled: false, expected: false },
+ { system: 'Linux', scale: 1.5, merges: false, overflow: false, hidden: false, disabled: false, expected: false },
+ { system: 'Linux', scale: 1.5, merges: true, overflow: true, hidden: true, disabled: false, expected: false },
+ { system: 'Linux', scale: 1.5, merges: true, overflow: true, hidden: false, disabled: true, expected: false },
+ ])('uses the native grid fallback only for affected geometry: %j', (scenario) => {
+ disposeFixture(fixture);
+ const data = workbookDataFactory();
+ const sheetData = data.sheets['sheet-1'];
+ sheetData.cellData = {};
+ sheetData.mergeData = scenario.merges ? [{ startRow: 0, endRow: 1, startColumn: 0, endColumn: 1 }] : [];
+ sheetData.showGridlines = scenario.hidden ? BooleanNumber.FALSE : BooleanNumber.TRUE;
+ fixture = createFixture(data);
+ const { spreadsheet, skeleton, mainCanvas, scene, cacheCanvas } = fixture;
+ const context = mainCanvas.getContext();
+ vi.spyOn(Tools, 'getSystemType').mockReturnValue(scenario.system);
+ context.setTransform(scenario.scale, 0, 0, scenario.scale, 0, 0);
+ if (scenario.overflow) {
+ skeleton.overflowCache.setValue(1, 1, { startRow: 1, endRow: 1, startColumn: 1, endColumn: 4 });
+ }
+ Reflect.set(spreadsheet, '_forceDisableGridlines', scenario.disabled);
+ const viewport = createViewportInfo(scene, cacheCanvas);
+ expect(Reflect.get(spreadsheet, '_requiresNativeGridlineRepaint').call(spreadsheet, context, skeleton, viewport, scenario.merges)).toBe(scenario.expected);
+ });
+
+ it('ignores historical grid cuts while finding an offscreen horizontal overflow anchor', () => {
+ disposeFixture(fixture);
+ const data = workbookDataFactory();
+ Object.assign(data.sheets['sheet-1'], { rowCount: 100, columnCount: 128, cellData: {}, mergeData: [], rowData: {}, columnData: {} });
+ fixture = createFixture(data);
+ const { spreadsheet, skeleton, mainCanvas, scene, cacheCanvas, workbook } = fixture;
+ const context = mainCanvas.getContext();
+ vi.spyOn(Tools, 'getSystemType').mockReturnValue('Linux');
+ context.setTransform(1.5, 0, 0, 1.5, 0, 0);
+ const { overflowCache, columnWidthAccumulation: columns, rowHeightAccumulation: rows } = skeleton;
+ overflowCache.setValue(0, 0, { startRow: 0, endRow: 0, startColumn: 0, endColumn: 100 });
+ overflowCache.setValue(42, 70, { startRow: 42, endRow: 42, startColumn: 70, endColumn: 75 });
+ const getRow = vi.spyOn(overflowCache, 'getRow');
+ const getMergedCellRange = vi.spyOn(workbook.getActiveSheet()!, 'getMergedCellRange');
+ const cacheBound = {
+ left: columns[19] + skeleton.rowHeaderWidthAndMarginLeft + 1,
+ right: columns[25] + skeleton.rowHeaderWidthAndMarginLeft - 1,
+ top: rows[39] + skeleton.columnHeaderHeightAndMarginTop + 1,
+ bottom: rows[44] + skeleton.columnHeaderHeightAndMarginTop - 1,
+ };
+ const viewport = createViewportInfo(scene, cacheCanvas, { cacheBound });
+ expect(skeleton.getRangeByViewBound(cacheBound)).toMatchObject({ startRow: 40, endRow: 44, startColumn: 20, endColumn: 25 });
+ const requiresRepaint = Reflect.get(spreadsheet, '_requiresNativeGridlineRepaint').bind(spreadsheet);
+ expect(requiresRepaint(context, skeleton, viewport, true)).toBe(false);
+ expect(getMergedCellRange).toHaveBeenCalledExactlyOnceWith(40, 20, 44, 25);
+ expect(getRow.mock.calls.map(([row]) => row)).toEqual([40, 41, 42, 43, 44]);
+ overflowCache.setValue(42, 0, { startRow: 42, endRow: 42, startColumn: 0, endColumn: 20 });
+ expect(requiresRepaint(context, skeleton, viewport, false)).toBe(true);
+ });
+
+ it.each(['invalidate', 'clear'])('rejects viewport reuse after a font metrics %s without font load events', (action) => {
+ const { spreadsheet, mainCanvas, scene, cacheCanvas } = fixture;
+ const info = createViewportInfo(scene, cacheCanvas);
+ spreadsheet.render(mainCanvas.getContext(), info);
+ expect(spreadsheet.canReuseViewportCache()).toBe(true);
+
+ if (action === 'invalidate') {
+ FontCache.invalidateMetrics(() => false);
+ } else {
+ FontCache.clearFontMeasureCache('12px Arial');
+ }
+ expect(spreadsheet.canReuseViewportCache()).toBe(false);
+
+ spreadsheet.render(mainCanvas.getContext(), info);
+ expect(spreadsheet.canReuseViewportCache()).toBe(true);
+ });
+
+ it.each([
+ { reset: 'range', key: 't', row: 2, col: 3 },
+ { reset: 'range', key: 'r', row: 3, col: 3 },
+ { reset: 'range', key: 'b', row: 3, col: 2 },
+ { reset: 'range', key: 'l', row: 2, col: 2 },
+ { reset: 'all', key: 't', row: 2, col: 3 },
+ { reset: 'all', key: 'r', row: 3, col: 3 },
+ { reset: 'all', key: 'b', row: 3, col: 2 },
+ { reset: 'all', key: 'l', row: 2, col: 2 },
+ ] as const)('refreshes a cached merged $key edge after $reset invalidation', ({ reset, key, row, col }) => {
+ disposeFixture(fixture);
+ const data = workbookDataFactory();
+ for (let r = 2; r <= 3; r++) {
+ for (let c = 2; c <= 3; c++) {
+ const cells = data.sheets['sheet-1'].cellData!;
+ (cells[r] ??= {})[c] = {
+ v: r === 2 && c === 2 ? 'merged title' : undefined,
+ s: {
+ bg: { rgb: '#fef3c7' },
+ bd: Object.fromEntries(['t', 'r', 'b', 'l'].map((side) => [side, {
+ s: BorderStyleTypes.THIN,
+ cl: { rgb: '#334455' },
+ }])),
+ },
+ };
+ }
+ }
+ fixture = createFixture(data);
+ const { skeleton, scene, cacheCanvas } = fixture;
+ const info = createViewportInfo(scene, cacheCanvas);
+ skeleton.setStylesCache(info);
+ expect(skeleton.stylesCache.border?.getValue(row, col)?.[key]).toEqual(expect.objectContaining({ color: '#334455' }));
+
+ const previous = skeleton.worksheet.getCellRaw(row, col)!;
+ const previousStyle = previous.s as IStyleData;
+ skeleton.worksheet.getCellMatrix().setValue(row, col, {
+ ...previous,
+ s: {
+ ...previousStyle,
+ bd: {
+ ...previousStyle.bd,
+ [key]: {
+ s: BorderStyleTypes.DOUBLE,
+ cl: { rgb: '#be123c' },
+ },
+ },
+ },
+ });
+ if (reset === 'range') {
+ skeleton.resetRangeCache([{ startRow: row, endRow: row, startColumn: col, endColumn: col }]);
+ } else {
+ skeleton.resetCache();
+ }
+ skeleton.setStylesCache({ ...info, isDirty: 0, shouldCacheUpdate: 0, diffX: 0.2 });
+ expect(skeleton.stylesCache.border?.getValue(row, col)?.[key]).toEqual(expect.objectContaining({
+ style: BorderStyleTypes.DOUBLE,
+ color: '#be123c',
+ }));
+ const opposites = {
+ t: { row: 3, col: 3, key: 'b' },
+ b: { row: 2, col: 2, key: 't' },
+ l: { row: 3, col: 3, key: 'r' },
+ r: { row: 2, col: 2, key: 'l' },
+ };
+ const opposite = opposites[key];
+ expect(skeleton.stylesCache.border?.getValue(opposite.row, opposite.col)?.[opposite.key])
+ .toEqual(expect.objectContaining({ color: '#334455' }));
+ });
+
+ it.each([false, true])('keeps consumer extensions ordered around native background, text and border draws, repair=%s', (repair) => {
+ const { spreadsheet, skeleton, scene, cacheCanvas, mainCanvas } = fixture;
+ expect(spreadsheet.backgroundExtension).toBeInstanceOf(Background);
+ expect(spreadsheet.borderExtension).toBeInstanceOf(Border);
+ const background = fixture.univer.__getInjector().createInstance(RenderOrderProbe, 'ConsumerBackground', 1, SHEET_EXTENSION_TYPE.BACKGROUND);
+ const early = fixture.univer.__getInjector().createInstance(RenderOrderProbe, 'ConsumerBeforeText', 25, SHEET_EXTENSION_TYPE.GRID);
+ const late = fixture.univer.__getInjector().createInstance(RenderOrderProbe, 'ConsumerAfterBorder', 70, SHEET_EXTENSION_TYPE.GRID);
+ spreadsheet.register(background, early, late);
+ const backgroundDraw = vi.spyOn(background, 'draw');
+ const earlyDraw = vi.spyOn(early, 'draw');
+ const lateDraw = vi.spyOn(late, 'draw');
+ const textDraw = vi.spyOn(spreadsheet.fontExtension, 'draw');
+ const borderDraw = vi.spyOn(spreadsheet.borderExtension, 'draw');
+ const info = createViewportInfo(scene, cacheCanvas);
+ skeleton.setStylesCache(info);
+ spreadsheet.draw(mainCanvas.getContext(), info, repair);
+
+ expect(backgroundDraw).toHaveBeenCalled();
+ expect(earlyDraw).toHaveBeenCalledOnce();
+ expect(lateDraw).toHaveBeenCalledOnce();
+ expect(backgroundDraw.mock.invocationCallOrder.at(-1)).toBeLessThan(earlyDraw.mock.invocationCallOrder[0]);
+ expect(earlyDraw.mock.invocationCallOrder[0]).toBeLessThan(textDraw.mock.invocationCallOrder[0]);
+ expect(textDraw.mock.invocationCallOrder[0]).toBeLessThan(borderDraw.mock.invocationCallOrder[0]);
+ expect(borderDraw.mock.invocationCallOrder[0]).toBeLessThan(lateDraw.mock.invocationCallOrder[0]);
+ });
+
+ it.each(['cache', 'swapped-cache', 'stale-cache', 'main', 'mac', 'printing', 'disabled'])('limits native gridline interior repair to the current Linux cache: %s', (mode) => {
+ const { spreadsheet, skeleton, scene, viewport, cacheCanvas, mainCanvas } = fixture;
+ const info = createViewportInfo(scene, cacheCanvas);
+ skeleton.setStylesCache(info);
+ const previousCache = viewport.canvas!;
+ if (mode === 'swapped-cache') {
+ viewport.swapCacheCanvas(cacheCanvas);
+ }
+ let canvas = viewport.canvas!;
+ if (mode === 'main') {
+ canvas = mainCanvas;
+ } else if (mode === 'stale-cache') {
+ canvas = cacheCanvas;
+ }
+ const context = canvas.getContext();
+ vi.spyOn(context, 'getSystemType').mockReturnValue(mode === 'mac' ? 'Mac' : 'Linux');
+ if (mode === 'printing') {
+ context.__mode = 'printing';
+ }
+ if (mode === 'disabled') {
+ vi.spyOn(spreadsheet, 'allowCache', 'get').mockReturnValue(false);
+ }
+ const repair = vi.spyOn(spreadsheet as unknown as {
+ _repairGridlineStroke: (...args: unknown[]) => void;
+ }, '_repairGridlineStroke');
+ try {
+ spreadsheet.draw(context, info);
+ } finally {
+ viewport.swapCacheCanvas(previousCache);
+ }
+ expect(repair.mock.calls.length > 0).toBe(mode === 'cache' || mode === 'swapped-cache');
+ });
+
it('updates the mixed screen gridline color after theme changes', () => {
const { scene, skeleton, viewport } = fixture;
const themeService = fixture.univer.__getInjector().get(ThemeService);
@@ -593,6 +821,89 @@ describe('spreadsheet integration', () => {
skeleton.dispose();
});
+ it.each([
+ { system: 'Linux', browser: 'Safari', fractional: true, printing: false, corner: true, native: true },
+ { system: 'Mac', browser: 'Safari', fractional: true, printing: false, corner: true, native: false },
+ { system: 'Unknown system', browser: 'Safari', fractional: true, printing: false, corner: true, native: false },
+ { system: 'Linux', browser: 'Chrome', fractional: true, printing: false, corner: true, native: false },
+ { system: 'Linux', browser: 'Safari', fractional: false, printing: false, corner: true, native: false },
+ { system: 'Linux', browser: 'Safari', fractional: true, printing: true, corner: true, native: false },
+ { system: 'Linux', browser: 'Safari', fractional: true, printing: false, corner: false, native: false },
+ ])('preserves native frozen-corner coverage without changing other cache paths: %j', (scenario) => {
+ const { spreadsheet, skeleton, scene, cacheCanvas, mainCanvas } = fixture;
+ const mainCtx = mainCanvas.getContext();
+ vi.spyOn(mainCtx, 'getSystemType').mockReturnValue(scenario.system);
+ vi.spyOn(mainCtx, 'getBrowserType').mockReturnValue(scenario.browser);
+ mainCtx.__mode = scenario.printing ? 'printing' : 'rendering';
+ const drawSpy = vi.spyOn(spreadsheet, 'draw');
+ const refreshSpy = vi.spyOn(spreadsheet, 'refreshCacheCanvas');
+ const info = createViewportInfo(scene, cacheCanvas, {
+ viewportKey: scenario.corner ? SHEET_VIEWPORT_KEY.VIEW_MAIN_LEFT_TOP : SHEET_VIEWPORT_KEY.VIEW_MAIN,
+ viewPortPosition: createBound(scenario.fractional ? 30.82 : 30, 16, 140, 67),
+ });
+
+ spreadsheet.render(mainCtx, info);
+
+ expect(drawSpy.mock.calls.some(([ctx]) => ctx === mainCtx)).toBe(scenario.native);
+ expect(refreshSpy).toHaveBeenCalledTimes(scenario.native ? 0 : 1);
+ expect(drawSpy.mock.calls.filter(([ctx]) => ctx === mainCtx)).toHaveLength(scenario.native ? 1 : 0);
+ expect(drawSpy.mock.calls.some(([ctx]) => ctx === cacheCanvas.getContext())).toBe(!scenario.native);
+ skeleton.dispose();
+ });
+
+ it('rebuilds the frozen-corner bitmap once after native paints even on a clean return to integral bounds', () => {
+ const { spreadsheet, skeleton, scene, cacheCanvas, mainCanvas } = fixture;
+ const mainCtx = mainCanvas.getContext();
+ vi.spyOn(mainCtx, 'getSystemType').mockReturnValue('Linux');
+ vi.spyOn(mainCtx, 'getBrowserType').mockReturnValue('Safari');
+ const drawSpy = vi.spyOn(spreadsheet, 'draw');
+ const refreshSpy = vi.spyOn(spreadsheet, 'refreshCacheCanvas');
+ spreadsheet.render(mainCtx, createViewportInfo(scene, cacheCanvas, {
+ viewportKey: SHEET_VIEWPORT_KEY.VIEW_MAIN_LEFT_TOP,
+ viewPortPosition: createBound(30, 16, 140, 67),
+ }));
+ expect(refreshSpy).toHaveBeenCalledOnce();
+ drawSpy.mockClear();
+ refreshSpy.mockClear();
+ spreadsheet.makeDirty(false);
+ const info = createViewportInfo(scene, cacheCanvas, {
+ viewportKey: SHEET_VIEWPORT_KEY.VIEW_MAIN_LEFT_TOP,
+ isDirty: 0,
+ isForceDirty: false,
+ shouldCacheUpdate: 0,
+ diffBounds: [],
+ diffCacheBounds: [],
+ viewPortPosition: createBound(30.82, 16, 140, 67),
+ });
+ spreadsheet.render(mainCtx, info);
+ spreadsheet.makeDirty(true);
+ spreadsheet.render(mainCtx, info);
+ expect(refreshSpy).not.toHaveBeenCalled();
+ expect(drawSpy.mock.calls.filter(([ctx]) => ctx === mainCtx)).toHaveLength(2);
+
+ spreadsheet.makeDirty(false);
+ spreadsheet.makeForceDirty(false);
+ drawSpy.mockClear();
+ const clean = {
+ ...info,
+ isDirty: 0,
+ isForceDirty: false,
+ shouldCacheUpdate: 0,
+ diffBounds: [],
+ diffCacheBounds: [],
+ diffX: 0,
+ diffY: 0,
+ viewPortPosition: createBound(30, 16, 140, 67),
+ };
+ spreadsheet.render(mainCtx, clean);
+ expect(drawSpy.mock.calls.some(([ctx]) => ctx === mainCtx)).toBe(false);
+ expect(refreshSpy).toHaveBeenCalledOnce();
+ spreadsheet.makeDirty(false);
+ spreadsheet.render(mainCtx, clean);
+ expect(refreshSpy).toHaveBeenCalledOnce();
+ skeleton.dispose();
+ });
+
it('renders sheet content from the header plus outline margin origin', () => {
const { spreadsheet, skeleton, scene, cacheCanvas, mainCanvas } = fixture;
const mainCtx = mainCanvas.getContext() as any;
@@ -642,18 +953,9 @@ describe('spreadsheet integration', () => {
viewportInfo.diffBounds.map((bound) => skeleton.getRangeByViewBound(bound))
);
- const fontExtension = { uKey: 'DefaultFontExtension', draw: vi.fn() };
- const borderExtension = { uKey: 'DefaultBorderExtension', draw: vi.fn() };
- (spreadsheet as any)._fontExtension = fontExtension;
- (spreadsheet as any)._borderExtension = borderExtension;
- vi.spyOn(spreadsheet as any, 'getExtensionsByOrder').mockReturnValue([
- fontExtension,
- borderExtension,
- {
- uKey: 'MockSheetExtension',
- draw: extensionDraw,
- },
- ]);
+ vi.mocked(spreadsheet.getExtensionsByOrder).mockRestore();
+ const fontDraw = vi.spyOn(spreadsheet.fontExtension, 'draw');
+ const borderDraw = vi.spyOn(spreadsheet.borderExtension, 'draw');
spreadsheet.draw(context, viewportInfo);
const cacheRange = skeleton.getCacheRangeByViewport(viewportInfo);
const overflowSafeRanges = viewportInfo.diffBounds.map((bound) => ({
@@ -661,11 +963,10 @@ describe('spreadsheet integration', () => {
startColumn: cacheRange.startColumn,
endColumn: cacheRange.endColumn,
}));
- expect(fontExtension.draw.mock.calls.at(-1)?.[4].viewRanges).toEqual(overflowSafeRanges);
- expect(borderExtension.draw.mock.calls.at(-1)?.[4].viewRanges).toEqual(overflowSafeRanges);
- expect(extensionDraw.mock.calls.at(-1)?.[4].viewRanges).toEqual(
- viewportInfo.diffBounds.map((bound) => skeleton.getRangeByViewBound(bound))
- );
+ expect(fontDraw.mock.calls.at(-1)?.[4].viewRanges).toEqual(overflowSafeRanges);
+ const borderRanges = [{ startRow: 1, endRow: 4, startColumn: 0, endColumn: 2 }];
+ expect(borderDraw.mock.calls.at(-1)?.[4].viewRanges).toEqual(borderRanges);
+ expect(borderDraw.mock.calls.at(-1)?.[3]).toEqual(borderRanges);
(spreadsheet as any)._refreshIncrementalState = false;
spreadsheet.paintNewAreaForScrolling(viewportInfo, {
@@ -699,7 +1000,7 @@ describe('spreadsheet integration', () => {
expect(spreadsheet.getDocuments()).toBeDefined();
- const noSkeletonSpreadsheet = new Spreadsheet('no-skeleton');
+ const noSkeletonSpreadsheet = fixture.univer.__getInjector().createInstance(Spreadsheet, 'no-skeleton');
expect(noSkeletonSpreadsheet.draw(context, viewportInfo)).toBeUndefined();
expect(noSkeletonSpreadsheet.isHit(Vector2.FromArray([10, 10]))).toBe(false);
expect(noSkeletonSpreadsheet.getNoMergeCellPositionByIndex(0, 0)).toEqual({
@@ -723,7 +1024,7 @@ describe('spreadsheet integration', () => {
});
skeleton.setStylesCache(createViewportInfo(scene, cacheCanvas));
- const fontExtension = new Font();
+ const fontExtension = fixture.univer.__getInjector().createInstance(Font);
spreadsheet.register(fontExtension);
Reflect.set(spreadsheet, '_fontExtension', fontExtension);
Reflect.set(skeleton, '_incrementalFontRenderRanges', [{
@@ -743,6 +1044,70 @@ describe('spreadsheet integration', () => {
expect(renderFontSpy.mock.calls.some(([, row, column]) => row === 0 && column === 0)).toBe(true);
});
+ it('keeps full-row border candidates when a merged diagonal intersects the damaged area', () => {
+ disposeFixture(fixture);
+ const data = workbookDataFactory();
+ const style = data.styles['style-bg-border'] as IStyleData;
+ style.bd!.tl_br = { s: BorderStyleTypes.THIN, cl: { rgb: '#be123c' } };
+ fixture = createFixture(data);
+ const { spreadsheet, skeleton, scene, cacheCanvas, mainCanvas } = fixture;
+ const info = createViewportInfo(scene, cacheCanvas, {
+ diffBounds: [createBound(100, 60, 220, 140)],
+ isDirty: 0,
+ isForceDirty: false,
+ });
+ skeleton.setStylesCache(info);
+ const border = vi.spyOn(spreadsheet.borderExtension, 'draw');
+ (spreadsheet as any)._refreshIncrementalState = true;
+ spreadsheet.draw(mainCanvas.getContext(), info);
+ const cacheRange = skeleton.getCacheRangeByViewport(info);
+ const expected = info.diffBounds.map((bound) => ({
+ ...skeleton.getRangeByViewBound(bound),
+ startColumn: cacheRange.startColumn,
+ endColumn: cacheRange.endColumn,
+ }));
+ expect(border.mock.calls.at(-1)?.[4].viewRanges).toEqual(expected);
+ });
+
+ it.each([
+ SHEET_VIEWPORT_KEY.VIEW_MAIN,
+ SHEET_VIEWPORT_KEY.VIEW_MAIN_LEFT,
+ SHEET_VIEWPORT_KEY.VIEW_MAIN_TOP,
+ ])('keeps incremental border owners inside the full paint range for %s', (viewportKey) => {
+ const { spreadsheet, skeleton, scene, cacheCanvas, mainCanvas } = fixture;
+ const info = createViewportInfo(scene, cacheCanvas, {
+ viewportKey,
+ cacheBound: createBound(118, 76, 262, 124),
+ diffBounds: [createBound(116, 74, 264, 126)],
+ isDirty: 0,
+ isForceDirty: false,
+ });
+ skeleton.setStylesCache(info);
+ const border = vi.spyOn(spreadsheet.borderExtension, 'draw');
+ spreadsheet.draw(mainCanvas.getContext(), info);
+ const fullRanges = border.mock.calls.at(-1)![4].viewRanges;
+ Reflect.set(spreadsheet, '_refreshIncrementalState', true);
+ spreadsheet.draw(mainCanvas.getContext(), info);
+ expect(border.mock.calls.at(-1)![4].viewRanges).toEqual(fullRanges);
+ expect(border.mock.calls.at(-1)![3]).toEqual(fullRanges);
+ });
+
+ it('does not paint border owners outside the full cache range', () => {
+ const { spreadsheet, skeleton, scene, cacheCanvas, mainCanvas } = fixture;
+ const info = createViewportInfo(scene, cacheCanvas, {
+ cacheBound: createBound(118, 76, 262, 124),
+ diffBounds: [createBound(900, 900, 1000, 1000)],
+ isDirty: 0,
+ isForceDirty: false,
+ });
+ skeleton.setStylesCache(info);
+ const border = vi.spyOn(spreadsheet.borderExtension, 'draw');
+ Reflect.set(spreadsheet, '_refreshIncrementalState', true);
+ spreadsheet.draw(mainCanvas.getContext(), info);
+ expect(border.mock.calls.at(-1)![3]).toEqual([]);
+ expect(border.mock.calls.at(-1)![4].viewRanges).toEqual([]);
+ });
+
it('skips merge gridline cleanup during merge-free drawing', () => {
const { spreadsheet, skeleton, scene, cacheCanvas, mainCanvas } = fixture;
const context = mainCanvas.getContext() as any;
@@ -765,7 +1130,7 @@ describe('spreadsheet integration', () => {
const context = mainCanvas.getContext();
const backgroundDraw = vi.fn();
const gridDraw = vi.fn();
- const clearRectSpy = vi.spyOn(context, 'clearRectByPrecision');
+ const clearRectSpy = vi.spyOn(context, 'clearRect');
const mergedRange = { startRow: 2, endRow: 3, startColumn: 2, endColumn: 3, rangeType: RANGE_TYPE.NORMAL };
vi.spyOn(skeleton, 'getCurrentRowColumnSegmentMergeData').mockReturnValue([mergedRange]);
vi.spyOn(skeleton.overflowCache, 'toNativeArray').mockReturnValue([]);
@@ -792,7 +1157,210 @@ describe('spreadsheet integration', () => {
expect(backgroundDraw.mock.invocationCallOrder[1]).toBeLessThan(gridDraw.mock.invocationCallOrder[0]);
});
- it('skips sparse extensions outside merge repair bounds on sheets with merged cells', () => {
+ it('clears overflow gridlines at integral physical pixels without changing stroke geometry or caller state', () => {
+ const { spreadsheet, mainCanvas } = fixture;
+ const context = mainCanvas.getContext();
+ context.setTransform(1.5, 0, 0, 1.5, -162.5, 100.5);
+ const clear = vi.spyOn(context, 'clearRect');
+ const line = vi.spyOn(context, 'moveToByPrecision');
+ const save = vi.spyOn(context._context, 'save');
+ const restore = vi.spyOn(context._context, 'restore');
+ const ranges = [
+ { startRow: 0, endRow: 0, startColumn: 0, endColumn: 0 },
+ { startRow: 1, endRow: 1, startColumn: 1, endColumn: 1 },
+ ];
+ let repainted = false;
+ const repaint = (clearedRanges: typeof ranges) => {
+ expect(clearedRanges).toBe(ranges);
+ expect(clear).toHaveBeenCalledTimes(2);
+ expect(context.getTransform()).toMatchObject({ a: 1.5, d: 1.5, e: -162.5, f: 100.5 });
+ repainted = true;
+ };
+ (spreadsheet as any)._clearRectangle(context, [25, 50], [54, 100], ranges, repaint);
+
+ expect(clear).toHaveBeenNthCalledWith(1, -162, 101, 81, 38);
+ expect(clear).toHaveBeenNthCalledWith(2, -81, 139, 69, 37);
+ expect(save).toHaveBeenCalledOnce();
+ expect(restore).toHaveBeenCalledOnce();
+ expect(line).toHaveBeenCalledWith(0, 0);
+ expect(line).toHaveBeenCalledWith(54, 25);
+ expect(repainted).toBe(true);
+ expect(context.getTransform()).toMatchObject({ a: 1.5, d: 1.5, e: -162.5, f: 100.5 });
+ });
+
+ it.each(['printing', 'rotation'])('keeps the native gridline clear for %s', (mode) => {
+ const { spreadsheet, mainCanvas } = fixture;
+ const context = mainCanvas.getContext();
+ if (mode === 'printing') {
+ context.__mode = 'printing';
+ } else {
+ context.setTransform(1, 0.2, 0, 1, 0, 0);
+ }
+ const clear = vi.spyOn(context, 'clearRectByPrecision');
+ (spreadsheet as any)._clearRectangle(context, [25], [54], [{ startRow: 0, endRow: 0, startColumn: 0, endColumn: 0 }]);
+ expect(clear).toHaveBeenCalledWith(0, 0, 54, 25);
+ });
+
+ it.each(['plain', 'shadow', 'filter', 'composite'])('keeps overflow repair ink and unsupported effects: %s', (mode) => {
+ const { spreadsheet, mainCanvas } = fixture;
+ const context = mainCanvas.getContext();
+ context.setTransform(1.5, 0, 0, 1.5, -162.5, 100.5);
+ const clear = vi.spyOn(context, 'clearRect');
+ const line = vi.spyOn(context, 'moveToByPrecision');
+ if (mode === 'shadow') context._context.shadowOffsetX = -100;
+ if (mode === 'filter') context._context.filter = 'blur(10px)';
+ if (mode === 'composite') context._context.globalCompositeOperation = 'copy';
+ const ranges = [0, 1, 2].map((column) => ({ startRow: 0, endRow: 0, startColumn: column, endColumn: column }));
+ let repainted: typeof ranges = [];
+ const target = spreadsheet as unknown as {
+ _clearRectangle(ctx: typeof context, rows: number[], columns: number[], ranges: typeof repainted,
+ redraw: (ranges: typeof repainted) => void, repair: boolean, clip: IBoundRectNoAngle): void;
+ };
+ const redraw = (cleared: typeof ranges) => {
+ repainted = cleared;
+ };
+ target._clearRectangle(context, [25], [54, 100, 150], ranges, redraw, false, { left: -80, top: 101, right: -60, bottom: 139 });
+ // The first range's bordering ink can reach the strip; the distant third range cannot.
+ expect(clear).toHaveBeenCalledTimes(mode === 'plain' ? 2 : 3);
+ expect(repainted).toEqual(mode === 'plain' ? ranges.slice(0, 2) : ranges);
+ expect(line).toHaveBeenCalledWith(0, 0);
+ expect(line).toHaveBeenCalledWith(54, 0);
+ expect(line.mock.calls.some(([left]) => left === 100)).toBe(mode !== 'plain');
+ expect(context.getTransform()).toMatchObject({ a: 1.5, d: 1.5, e: -162.5, f: 100.5 });
+ });
+
+ it('redraws uncropped text from beyond an adjacent row when its ink enters the damage strip', () => {
+ disposeFixture(fixture);
+ const data = workbookDataFactory();
+ const sheet = data.sheets['sheet-1'];
+ sheet.mergeData = [];
+ sheet.rowData = {};
+ sheet.columnData = {};
+ sheet.rowCount = 200;
+ sheet.defaultRowHeight = 4;
+ sheet.defaultColumnWidth = 500;
+ sheet.cellData = { 4: {
+ 0: { v: 'TALL SOURCE', s: { fs: 72, ff: 'Vertical overflow test', tb: WrapStrategy.OVERFLOW } },
+ 1: { v: 'TALL OTHER', s: { fs: 72, ff: 'Vertical overflow test', tb: WrapStrategy.OVERFLOW } },
+ } };
+ fixture = createFixture(data);
+ const { spreadsheet, skeleton, scene, cacheCanvas, mainCanvas } = fixture;
+ // Canvas in JSDOM cannot measure glyph ink. Keep FontCache real and replace that native boundary only.
+ FontCache.getMeasureText('', '12px sans-serif');
+ const measurement: CanvasRenderingContext2D = Reflect.get(FontCache, '_context');
+ const measure = vi.isMockFunction(measurement.measureText)
+ ? vi.mocked(measurement.measureText).getMockImplementation()!
+ : measurement.measureText;
+ vi.spyOn(measurement, 'measureText').mockImplementation((text) => {
+ const metrics = measure.call(measurement, text);
+ return measurement.font.includes('Vertical overflow test')
+ ? {
+ ...metrics,
+ width: metrics.width,
+ fontBoundingBoxAscent: 80,
+ fontBoundingBoxDescent: 16,
+ actualBoundingBoxAscent: 75,
+ actualBoundingBoxDescent: 15,
+ }
+ : metrics;
+ });
+ FontCache.invalidateMetrics((font) => font.includes('Vertical overflow test'));
+ const info = createViewportInfo(scene, cacheCanvas, { cacheBound: createBound(0, 0, 1000, 500) });
+ skeleton.setStylesCache(info);
+ const context = mainCanvas.getContext();
+ const fill = vi.spyOn(context._context, 'fillText');
+ const font = spreadsheet.getExtensionByKey('DefaultFontExtension') as Font;
+ const range = { startRow: 0, endRow: 0, startColumn: 0, endColumn: 0 };
+ font.draw(context, { scaleX: 1, scaleY: 1 }, skeleton, [range], {
+ viewRanges: [range],
+ viewBound: info.cacheBound,
+ checkOutOfViewBound: true,
+ hasMergeData: false,
+ textClipBound: createBound(0, 0, 500, 4),
+ viewportKey: info.viewportKey,
+ });
+ try {
+ expect(fill.mock.calls.map(([text]) => text)).toContain('TALL SOURCE');
+ const reads = vi.spyOn(skeleton.stylesCache.fontMatrix, 'getValue');
+ const farRange = { startRow: 150, endRow: 150, startColumn: 0, endColumn: 0 };
+ font.draw(context, { scaleX: 1, scaleY: 1 }, skeleton, [farRange], {
+ viewRanges: [farRange],
+ viewBound: createBound(0, skeleton.columnHeaderHeightAndMarginTop + 400, 1000, skeleton.columnHeaderHeightAndMarginTop + 800),
+ checkOutOfViewBound: true,
+ hasMergeData: false,
+ textClipBound: createBound(0, 600, 500, 604),
+ viewportKey: info.viewportKey,
+ });
+ // A previously visited large font must not expand an unrelated cache's source-row scan.
+ expect(reads).toHaveBeenCalled();
+ expect(reads.mock.calls.every(([row]) => row === 150)).toBe(true);
+ skeleton.resetRangeCache([{ startRow: 4, endRow: 4, startColumn: 0, endColumn: 0 }]);
+ expect(skeleton.getPlainTextVerticalOverflow()).toBeGreaterThan(0);
+ skeleton.resetRangeCache([{ startRow: 4, endRow: 4, startColumn: 1, endColumn: 1 }]);
+ expect(skeleton.getPlainTextVerticalOverflow()).toBe(0);
+ skeleton.resetCache();
+ expect(skeleton.getPlainTextVerticalOverflow()).toBe(0);
+ } finally {
+ FontCache.invalidateMetrics((font) => font.includes('Vertical overflow test'));
+ }
+ });
+
+ it.each(['x', 'y'])('skips plain overflow glyphs wholly outside the physical %s damage clip', (axis) => {
+ disposeFixture(fixture);
+ const data = workbookDataFactory();
+ const sheet = data.sheets['sheet-1'];
+ sheet.mergeData = [];
+ sheet.rowData = {};
+ sheet.columnData = {};
+ sheet.cellData = {
+ 0: { 0: { v: 'left-'.repeat(30) }, 6: { v: 'right-'.repeat(30) } },
+ 6: { 0: { v: 'bottom-'.repeat(30) } },
+ };
+ fixture = createFixture(data);
+ const { spreadsheet, skeleton, scene, cacheCanvas, mainCanvas } = fixture;
+ const info = createViewportInfo(scene, cacheCanvas, { cacheBound: createBound(0, 0, 1000, 500) });
+ skeleton.setStylesCache(info);
+ const context = mainCanvas.getContext();
+ context.setTransform(1.34, 0, 0, 1.34, 10, 20);
+ const fill = vi.spyOn(context._context, 'fillText');
+ const clip = axis === 'x'
+ ? createBound(432 * 1.34 + 13, 20, 864 * 1.34 + 10, 24 * 1.34 + 20)
+ : createBound(10, 144 * 1.34 + 23, 864 * 1.34 + 10, 168 * 1.34 + 20);
+ const font = spreadsheet.getExtensionByKey('DefaultFontExtension') as Font;
+ const render = (textClipBound?: IBoundRectNoAngle) => {
+ fill.mockClear();
+ font.draw(context, { scaleX: 1, scaleY: 1 }, skeleton, [], {
+ viewRanges: [{ startRow: 0, endRow: 19, startColumn: 0, endColumn: 11 }],
+ checkOutOfViewBound: true,
+ hasMergeData: false,
+ textClipBound,
+ viewportKey: info.viewportKey,
+ });
+ return fill.mock.calls.map(([value]) => value).join('');
+ };
+ const text = render(clip);
+ expect(text).toContain(axis === 'x' ? 'right-' : 'bottom-');
+ expect(text).not.toContain('left-');
+ expect(text).not.toContain(axis === 'x' ? 'bottom-' : 'right-');
+ const fullText = render();
+ expect(fullText).toContain('left-');
+ expect(fullText).toContain('right-');
+ expect(fullText).toContain('bottom-');
+ if (axis === 'x') {
+ // Retain a cell ending one physical pixel outside the damage edge.
+ const overflow = skeleton.overflowCache.getValue(0, 0)!;
+ const renderCell = vi.spyOn(font, '_renderFontEachCell');
+ render({ ...clip, left: skeleton.columnWidthAccumulation[overflow.endColumn] * 1.34 + 11 });
+ expect(renderCell.mock.calls.some(([, row, column]) => row === 0 && column === 0)).toBe(true);
+ }
+ context.__mode = 'printing';
+ const printedText = render(clip);
+ expect(printedText).toContain('left-');
+ expect(printedText).toContain('right-');
+ expect(printedText).toContain('bottom-');
+ });
+
+ it.each([false, true])('skips absent sparse extensions on merged sheets, repair=%s', (repair) => {
const { spreadsheet, skeleton, scene, cacheCanvas, mainCanvas } = fixture;
const context = mainCanvas.getContext() as any;
const sparseDraw = vi.fn();
@@ -814,13 +1382,48 @@ describe('spreadsheet integration', () => {
spreadsheet.draw(context, createViewportInfo(scene, cacheCanvas, {
diffBounds: [createBound(100, 60, 220, 140)],
diffCacheBounds: [createBound(100, 60, 220, 140)],
- }));
+ }), repair);
(spreadsheet as any)._refreshIncrementalState = false;
expect(sparseDraw).not.toHaveBeenCalled();
expect(regularDraw).toHaveBeenCalledOnce();
});
+ it.each([false, true])('includes an off-strip merged feature through a visible cell, hidden=%s', (hidden) => {
+ disposeFixture(fixture);
+ const data = workbookDataFactory();
+ const sheet = data.sheets['sheet-1'];
+ sheet.mergeData = [{ startRow: 0, endRow: 6, startColumn: 0, endColumn: 4 }];
+ const cell: ICellDataForSheetInterceptor = { markers: { tr: { color: '#ff0000', size: 4 } } };
+ sheet.cellData = { 0: { 0: cell } };
+ if (hidden) {
+ sheet.rowData = { 1: { hd: BooleanNumber.TRUE } };
+ sheet.columnData = { 0: { hd: BooleanNumber.TRUE } };
+ }
+ fixture = createFixture(data);
+ const { spreadsheet, scene, cacheCanvas, mainCanvas } = fixture;
+ const injector = fixture.univer.__getInjector();
+ injector.add([Marker]);
+ const marker = injector.get(Marker);
+ spreadsheet.register(marker);
+ const markerDraw = vi.spyOn(marker, 'draw');
+ const fill = vi.spyOn(mainCanvas.getContext(), 'fill');
+ Reflect.set(spreadsheet, '_refreshIncrementalState', true);
+ spreadsheet.draw(mainCanvas.getContext(), createViewportInfo(scene, cacheCanvas, {
+ diffBounds: [createBound(100, 60, 220, 140)],
+ diffCacheBounds: [createBound(100, 60, 220, 140)],
+ }), true);
+ Reflect.set(spreadsheet, '_refreshIncrementalState', false);
+ expect(markerDraw).toHaveBeenCalledOnce();
+ expect(markerDraw.mock.calls[0][3]).toContainEqual({
+ startRow: hidden ? 2 : 1,
+ endRow: hidden ? 2 : 1,
+ startColumn: hidden ? 1 : 0,
+ endColumn: hidden ? 1 : 0,
+ });
+ expect(fill).toHaveBeenCalled();
+ });
+
it('does not skip conditional-formatting render extensions during sparse scans', () => {
const { spreadsheet, skeleton, scene, cacheCanvas, mainCanvas } = fixture;
const context = mainCanvas.getContext() as any;
@@ -956,9 +1559,103 @@ describe('spreadsheet integration', () => {
}]);
});
+ it.each([
+ { axis: 'row', edge: 'cell', delta: 5 / 6 },
+ { axis: 'column', edge: 'cell', delta: 5 / 6 },
+ { axis: 'row', edge: 'stroke', delta: 1 },
+ { axis: 'column', edge: 'stroke', delta: 1 },
+ ])('includes the $axis $edge intersecting a repair edge', ({ axis, edge, delta }) => {
+ disposeFixture(fixture);
+ const data = workbookDataFactory();
+ const sheet = data.sheets['sheet-1'];
+ sheet.rowCount = 160;
+ sheet.columnCount = 64;
+ sheet.defaultRowHeight = 25;
+ sheet.defaultColumnWidth = 54;
+ sheet.columnHeader = { height: 24 };
+ sheet.rowData = {};
+ sheet.columnData = {};
+ sheet.mergeData = [];
+ sheet.cellData = { 13: { 3: { v: 'repair edge', s: 'style-bg-border' } } };
+ fixture = createFixture(data);
+ const { spreadsheet, skeleton, scene, cacheCanvas, mainCanvas } = fixture;
+ cacheCanvas.setSize(1000, 760, 3);
+ const context = mainCanvas.getContext();
+ context.setTransform(6, 0, 0, 6, 0, 0);
+ const damage = axis === 'row'
+ ? createBound(46, 373 + delta, 700, 450)
+ : createBound(261 + delta, 24, 500, 450);
+ const viewportInfo = createViewportInfo(scene, cacheCanvas, {
+ cacheBound: createBound(0, 0, 800, 1000),
+ diffBounds: [damage],
+ diffCacheBounds: [damage],
+ diffX: axis === 'column' ? -1 : 0,
+ diffY: axis === 'row' ? -1 : 0,
+ });
+ skeleton.setStylesCache(viewportInfo);
+ const extension = edge === 'stroke' ? spreadsheet.borderExtension : spreadsheet.backgroundExtension;
+ const draw = vi.spyOn(extension, 'draw');
+
+ spreadsheet.paintNewAreaForScrolling(viewportInfo, {
+ cacheCanvas,
+ cacheCtx: cacheCanvas.getContext(),
+ mainCtx: context,
+ topOrigin: 0,
+ leftOrigin: 0,
+ bufferEdgeX: viewportInfo.bufferEdgeX,
+ bufferEdgeY: viewportInfo.bufferEdgeY,
+ rowHeaderWidthAndMarginLeft: skeleton.rowHeaderWidthAndMarginLeft,
+ columnHeaderHeightAndMarginTop: skeleton.columnHeaderHeightAndMarginTop,
+ scaleX: 6,
+ scaleY: 6,
+ });
+
+ const ranges = draw.mock.calls.flatMap((call) => call[3]);
+ expect(ranges.some((range) => range.startRow <= 13 && range.endRow >= 13
+ && range.startColumn <= 3 && range.endColumn >= 3)).toBe(true);
+ });
+
+ it('keeps viewport ranges without recalculating styles for an unchanged cached viewport', () => {
+ const { spreadsheet, skeleton, scene, cacheCanvas, mainCanvas } = fixture;
+ skeleton.setStylesCache(createViewportInfo(scene, cacheCanvas));
+ spreadsheet.makeDirty(false);
+ spreadsheet.makeForceDirty(false);
+ const styleSpy = vi.spyOn(skeleton, 'setStylesCache');
+ const rangeSpy = vi.spyOn(skeleton, 'updateVisibleRange');
+ const viewportInfo = createViewportInfo(scene, cacheCanvas, {
+ isDirty: 0,
+ isForceDirty: false,
+ shouldCacheUpdate: 0,
+ });
+
+ spreadsheet.render(mainCanvas.getContext(), viewportInfo);
+
+ expect(styleSpy).not.toHaveBeenCalled();
+ expect(rangeSpy).toHaveBeenCalledWith(viewportInfo);
+ expect(skeleton.rowColumnSegment).toEqual(skeleton.getCacheRangeByViewport(viewportInfo));
+ });
+
+ it.each(['dirty', 'uncached'])('calculates styles for a %s viewport even without scroll movement', (mode) => {
+ const { spreadsheet, skeleton, scene, cacheCanvas, mainCanvas } = fixture;
+ spreadsheet.makeForceDirty(false);
+ spreadsheet.makeDirty(mode === 'dirty');
+ const styleSpy = vi.spyOn(skeleton, 'setStylesCache');
+ const viewportInfo = createViewportInfo(scene, cacheCanvas, {
+ cacheCanvas: mode === 'uncached' ? undefined : cacheCanvas,
+ isDirty: 0,
+ isForceDirty: false,
+ shouldCacheUpdate: 0,
+ });
+
+ spreadsheet.render(mainCanvas.getContext(), viewportInfo);
+
+ expect(styleSpy).toHaveBeenCalledOnce();
+ });
+
it('skips style cache cell visits when scrolling inside the existing cache area', () => {
const { skeleton, scene, cacheCanvas } = fixture;
vi.spyOn(skeleton.worksheet, 'getMergeData').mockReturnValue([]);
+ skeleton.setStylesCache(createViewportInfo(scene, cacheCanvas));
const styleCellSpy = vi.spyOn(skeleton as any, '_setStylesCacheForOneCell');
const viewportInfo = createViewportInfo(scene, cacheCanvas, {
diffBounds: [createBound(100, 60, 220, 140)],
@@ -976,7 +1673,7 @@ describe('spreadsheet integration', () => {
expect(skeleton.rowColumnSegment).toEqual(skeleton.getCacheRangeByViewport(viewportInfo));
});
- it('reuses cached member styles while rebuilding merged borders during scrolling', () => {
+ it('reuses prepared member and merged styles while scrolling within the covered range', () => {
const { skeleton, scene, cacheCanvas } = fixture;
skeleton.setStylesCache(createViewportInfo(scene, cacheCanvas));
const cachedStyle = skeleton.stylesCache.fontMatrix.getValue(1, 1);
@@ -994,7 +1691,73 @@ describe('spreadsheet integration', () => {
}));
expect(skeleton.stylesCache.fontMatrix.getValue(1, 1)).toBe(cachedStyle);
- expect(borderStyleSpy.mock.calls.some(([, , , options]) => options?.mergeRange)).toBe(true);
+ expect(borderStyleSpy).not.toHaveBeenCalled();
+ });
+
+ it('reuses a fully prepared merged anchor without recomposing its perimeter during scrolling', () => {
+ const { skeleton, scene, cacheCanvas } = fixture;
+ skeleton.setStylesCache(createViewportInfo(scene, cacheCanvas));
+ const mergeRange = skeleton.worksheet.getMergeData()[0];
+ const cachedFont = skeleton.stylesCache.fontMatrix.getValue(2, 2);
+ const composed = vi.spyOn(skeleton.worksheet, 'getComposedCellStyleByCellData');
+ const borders = vi.spyOn(skeleton as any, '_setMergeBorderProps');
+
+ (skeleton as any)._setStylesCacheForOneCell(2, 2, { mergeRange, reuseExisting: true, hasMergeData: true });
+
+ expect(composed).not.toHaveBeenCalled();
+ expect(borders).not.toHaveBeenCalled();
+ expect(skeleton.stylesCache.fontMatrix.getValue(2, 2)).toBe(cachedFont);
+ });
+
+ it('prepares all merged edges after the ordinary anchor was visited first', () => {
+ const { skeleton } = fixture;
+ const mergeRange = skeleton.worksheet.getMergeData()[0];
+ (skeleton as any)._setStylesCacheForOneCell(2, 2, {
+ cacheItem: { bg: true, border: true },
+ hasMergeData: true,
+ reuseExisting: true,
+ });
+ const borders = vi.spyOn(skeleton as any, '_setMergeBorderProps');
+ (skeleton as any)._setStylesCacheForOneCell(2, 2, { mergeRange, reuseExisting: true, hasMergeData: true });
+ expect(borders).toHaveBeenCalledTimes(4);
+ });
+
+ it('recomposes merged styles after a theme change even during a scroll preparation pass', () => {
+ const { skeleton, scene, cacheCanvas } = fixture;
+ skeleton.setStylesCache(createViewportInfo(scene, cacheCanvas));
+ const mergeRange = skeleton.worksheet.getMergeData()[0];
+ const composed = vi.spyOn(skeleton.worksheet, 'getComposedCellStyleByCellData');
+ const themeService = fixture.univer.__getInjector().get(ThemeService);
+ const theme = themeService.getCurrentTheme();
+ themeService.setTheme({ ...theme, gray: { ...theme.gray, 200: '#ccddee' } });
+ (skeleton as any)._setStylesCacheForOneCell(2, 2, { mergeRange, reuseExisting: true, hasMergeData: true });
+ expect(composed).toHaveBeenCalled();
+ });
+
+ it('bounds dense background candidates to the damaged columns across many cached rows', () => {
+ disposeFixture(fixture);
+ const data = workbookDataFactory();
+ const sheet = data.sheets['sheet-1'];
+ sheet.columnCount = 64;
+ sheet.mergeData = [];
+ sheet.cellData = Object.fromEntries(Array.from({ length: 20 }, (_, row) => [row, Object.fromEntries(Array.from({ length: 64 }, (_, col) => [col, { s: { bg: { rgb: '#fef3c7' } } }]))]));
+ fixture = createFixture(data);
+ const { spreadsheet, skeleton, scene, cacheCanvas, mainCanvas } = fixture;
+ const info = createViewportInfo(scene, cacheCanvas, { cacheBound: createBound(0, 0, 5000, 600) });
+ skeleton.setStylesCache(info);
+ const background = spreadsheet.backgroundExtension;
+ const candidates = vi.spyOn(background, 'renderBGByCell');
+ const damage = [{ startRow: 0, endRow: 19, startColumn: 20, endColumn: 21 }];
+
+ background.draw(mainCanvas.getContext(), { scaleX: 1, scaleY: 1 }, skeleton, damage, {
+ viewRanges: damage,
+ checkOutOfViewBound: true,
+ hasMergeData: false,
+ viewportKey: 'viewMain',
+ });
+
+ expect(candidates).toHaveBeenCalledTimes(38);
+ expect(candidates.mock.calls.every(([, , col]) => col === 20 || col === 21)).toBe(true);
});
it('skips merge lookups for one-cell style cache when merge data is absent', () => {
@@ -1052,6 +1815,41 @@ describe('spreadsheet integration', () => {
expect(getStyleSpy.mock.calls.length).toBe(getStyleCalls);
});
+ it('reuses styled cells without text during incremental scrolling', () => {
+ const { skeleton } = fixture;
+ const getCellSpy = vi.spyOn(skeleton.worksheet, 'getCell');
+ const getStyleSpy = vi.spyOn(skeleton.worksheet, 'getComposedCellStyleByCellData');
+ const options = { cacheItem: { bg: true, border: true }, reuseExisting: true };
+ (skeleton as any)._setStylesCacheForOneCell(0, 4, options);
+ expect(skeleton.stylesCache.fontMatrix.getValue(0, 4)).toBeUndefined();
+ getCellSpy.mockClear();
+ getStyleSpy.mockClear();
+
+ (skeleton as any)._setStylesCacheForOneCell(0, 4, options);
+
+ expect(getCellSpy).not.toHaveBeenCalled();
+ expect(getStyleSpy).not.toHaveBeenCalled();
+ expect(skeleton.stylesCache.backgroundPositions?.getValue(0, 4)).toBeDefined();
+ expect(skeleton.stylesCache.border?.getValue(0, 4)).toBeDefined();
+ });
+
+ it.each(['range', 'all'])('invalidates cached text absence on %s cache reset', (reset) => {
+ const { skeleton } = fixture;
+ const options = { cacheItem: { bg: true, border: true }, reuseExisting: true };
+ (skeleton as any)._setStylesCacheForOneCell(0, 4, options);
+ if (reset === 'range') {
+ skeleton.resetRangeCache([{ startRow: 0, endRow: 0, startColumn: 4, endColumn: 4 }]);
+ } else {
+ skeleton.resetCache();
+ }
+ const cell = skeleton.worksheet.getCellRaw(0, 4)!;
+ skeleton.worksheet.getCellMatrix().setValue(0, 4, { ...cell, v: 'New text' });
+
+ (skeleton as any)._setStylesCacheForOneCell(0, 4, options);
+
+ expect(skeleton.stylesCache.fontMatrix.getValue(0, 4)?.cellData?.v).toBe('New text');
+ });
+
it('skips overflow boundary scanning when text fits in the current column', () => {
const { skeleton } = fixture;
const overflowBoundSpy = vi.spyOn(skeleton as any, '_getOverflowBound');
@@ -1196,7 +1994,7 @@ describe('spreadsheet integration', () => {
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 });
+ const cacheCanvas = fixture.univer.__getInjector().createInstance(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, {
@@ -1221,7 +2019,7 @@ describe('spreadsheet integration', () => {
cacheCanvas.dispose();
});
- it('repairs the full merged range incrementally so merged text remains visible', () => {
+ it('clips merge repair to the exposed strip while retaining the merged text anchor', () => {
const { spreadsheet, skeleton, mainCanvas, cacheCanvas, scene } = fixture;
const context = mainCanvas.getContext();
const mergeInfo = skeleton.getCellWithCoordByIndex(2, 2, false).mergeInfo;
@@ -1245,22 +2043,83 @@ describe('spreadsheet integration', () => {
const paintSpy = vi.spyOn(spreadsheet, 'paintNewAreaForScrolling');
const refreshSpy = vi.spyOn(spreadsheet, 'refreshCacheCanvas');
- const drawSpy = vi.spyOn(spreadsheet, 'draw').mockImplementation(() => {});
+ skeleton.setStylesCache({ ...viewportInfo, isDirty: 1, shouldCacheUpdate: 1 });
+ const drawSpy = vi.spyOn(spreadsheet, 'draw');
+ const fontSpy = vi.spyOn(spreadsheet.fontExtension, '_renderFontEachCell');
+ const clear = vi.spyOn(cacheCanvas.getContext(), 'clearRect');
spreadsheet.renderByViewports(context, viewportInfo, skeleton);
expect(refreshSpy).not.toHaveBeenCalled();
expect(paintSpy).toHaveBeenCalledOnce();
- expect(drawSpy).toHaveBeenCalledWith(expect.anything(), expect.objectContaining({
- diffBounds: [mergedBound],
- }), true);
+ const repair = drawSpy.mock.calls.find((call) => call[2]);
+ expect(repair?.[1].diffBounds).toEqual(viewportInfo.diffBounds.map((bound) => createBound(
+ bound.left - 2,
+ bound.top - 2,
+ bound.right + 2,
+ bound.bottom + 2
+ )));
+ expect(clear).toHaveBeenCalledWith(mergeInfo.endX - 8 + 12, mergeInfo.startY + 8, 8, mergeInfo.endY - mergeInfo.startY);
+ expect(fontSpy.mock.calls.some(([, row, col]) => row === 2 && col === 2)).toBe(true);
+ });
+
+ it('keeps a wide merged title incremental when only a narrow frozen strip is exposed', () => {
+ const { spreadsheet, skeleton, mainCanvas, cacheCanvas, scene } = fixture;
+ skeleton.worksheet.setMergeData([{ startRow: 0, endRow: 2, startColumn: 0, endColumn: 11 }]);
+ const cacheBound = createBound(46, 28, 506, 118);
+ const viewportInfo = createViewportInfo(scene, cacheCanvas, {
+ viewportKey: SHEET_VIEWPORT_KEY.VIEW_MAIN_TOP,
+ cacheBound,
+ diffBounds: [createBound(498, 28, 506, 118)],
+ diffCacheBounds: [],
+ diffX: -8,
+ diffY: 0,
+ isDirty: 0,
+ isForceDirty: false,
+ shouldCacheUpdate: 0,
+ });
+ skeleton.setStylesCache({ ...viewportInfo, isDirty: 1, shouldCacheUpdate: 1 });
+ spreadsheet.makeDirty(false);
+ spreadsheet.makeForceDirty(false);
+ const refresh = vi.spyOn(spreadsheet, 'refreshCacheCanvas');
+ const draw = vi.spyOn(spreadsheet, 'draw');
+ const font = vi.spyOn(spreadsheet.fontExtension, '_renderFontEachCell');
+ const clear = vi.spyOn(cacheCanvas.getContext(), 'clearRect');
+ spreadsheet.renderByViewports(mainCanvas.getContext(), viewportInfo, skeleton);
+ expect(refresh).not.toHaveBeenCalled();
+ const repair = draw.mock.calls.find((call) => call[2]);
+ expect(repair?.[1].diffBounds).toEqual([createBound(496, 26, 508, 102)]);
+ expect(clear).toHaveBeenCalledWith(464, 8, 8, 72);
+ expect(font.mock.calls.some(([, row, col]) => row === 0 && col === 0)).toBe(true);
+ });
+
+ it('retains whole-merge repair for fractional bitmap shifts', () => {
+ const { spreadsheet, skeleton, mainCanvas, cacheCanvas, scene } = fixture;
+ skeleton.worksheet.setMergeData([{ startRow: 0, endRow: 2, startColumn: 0, endColumn: 11 }]);
+ const viewportInfo = createViewportInfo(scene, cacheCanvas, {
+ cacheBound: createBound(46, 28, 506, 118),
+ diffBounds: [createBound(498, 28, 506, 118)],
+ diffCacheBounds: [],
+ diffX: -0.5,
+ diffY: 0,
+ isDirty: 0,
+ isForceDirty: false,
+ shouldCacheUpdate: 0,
+ });
+ spreadsheet.makeDirty(false);
+ spreadsheet.makeForceDirty(false);
+ const refresh = vi.spyOn(spreadsheet, 'refreshCacheCanvas');
+ const paint = vi.spyOn(spreadsheet, 'paintNewAreaForScrolling');
+ spreadsheet.renderByViewports(mainCanvas.getContext(), viewportInfo, skeleton);
+ expect(refresh).toHaveBeenCalledOnce();
+ expect(paint).not.toHaveBeenCalled();
});
it('refreshes the cache when merge repair covers most of the cache area', () => {
const { spreadsheet, skeleton, mainCanvas, cacheCanvas, scene } = fixture;
const context = mainCanvas.getContext();
const viewportInfo = createViewportInfo(scene, cacheCanvas, {
- diffBounds: [createBound(0, 200, 460, 280)],
+ diffBounds: [createBound(46, 28, 506, 240)],
diffCacheBounds: [],
diffX: 0,
diffY: -80,
@@ -1270,8 +2129,8 @@ describe('spreadsheet integration', () => {
});
spreadsheet.makeDirty(false);
spreadsheet.makeForceDirty(false);
- vi.spyOn(skeleton.worksheet, 'getMergedCellRange').mockReturnValue([
- { startRow: 0, endRow: 9, startColumn: 0, endColumn: 6, rangeType: RANGE_TYPE.NORMAL },
+ skeleton.worksheet.setMergeData([
+ { startRow: 0, endRow: 9, startColumn: 0, endColumn: 11, rangeType: RANGE_TYPE.NORMAL },
]);
const paintSpy = vi.spyOn(spreadsheet, 'paintNewAreaForScrolling');
@@ -1305,7 +2164,641 @@ describe('spreadsheet integration', () => {
expect(drawSpy).not.toHaveBeenCalled();
});
- it('refreshes cache for horizontal cache updates to avoid exposing stale cache edges', () => {
+ it('limits horizontal style work to exposed columns while preparing new backgrounds', () => {
+ const { skeleton, scene, cacheCanvas } = fixture;
+ const initial = createViewportInfo(scene, cacheCanvas, { cacheBound: createBound(0, 0, 300, 280) });
+ skeleton.setStylesCache(initial);
+ const cachedFont = skeleton.stylesCache.fontMatrix.getValue(0, 1);
+ expect(skeleton.stylesCache.backgroundPositions?.getValue(0, 4)).toBeUndefined();
+ const cacheBuilder = skeleton as unknown as { _setStylesCacheForOneCell(...args: unknown[]): void };
+ const styleVisits = vi.spyOn(cacheBuilder, '_setStylesCacheForOneCell');
+ const changed = createViewportInfo(scene, cacheCanvas, {
+ cacheBound: createBound(72, 0, 460, 280),
+ diffBounds: [createBound(440, 0, 460, 280)],
+ diffCacheBounds: [createBound(300, 0, 460, 280)],
+ diffX: -72,
+ diffY: 0,
+ isDirty: 0,
+ isForceDirty: false,
+ shouldCacheUpdate: 1,
+ });
+ skeleton.setStylesCache(changed, { scaleY: 1 });
+ const incrementalVisits = styleVisits.mock.calls.length;
+ expect(skeleton.stylesCache.backgroundPositions?.getValue(0, 4)).toBeDefined();
+ expect(skeleton.stylesCache.fontMatrix.getValue(0, 1)).toBe(cachedFont);
+ styleVisits.mockClear();
+ skeleton.setStylesCache({ ...changed, isDirty: 1 }, { scaleY: 1 });
+ expect(incrementalVisits).toBeLessThan(styleVisits.mock.calls.length);
+ });
+
+ it.each(['distance', 'origin'])('reuses prepared merged styles when fractional %s needs a pixel refresh', (fractional) => {
+ const { spreadsheet, skeleton, viewport, scene, mainCanvas } = fixture;
+ const cacheCanvas = viewport.canvas!;
+ cacheCanvas.setSize(700, 420, 1);
+ skeleton.setStylesCache(createViewportInfo(scene, cacheCanvas));
+ const mergedFont = skeleton.stylesCache.fontMatrix.getValue(2, 2);
+ expect(mergedFont).toBeDefined();
+ const prepareFont = vi.spyOn(skeleton, '_setFontStylesCache');
+ const renderFont = vi.spyOn(spreadsheet.fontExtension, '_renderFontEachCell');
+ spreadsheet.makeDirty(false);
+ spreadsheet.makeForceDirty(false);
+ const context = mainCanvas.getContext();
+ if (fractional === 'origin') {
+ context.translate(0.5, 0);
+ }
+ spreadsheet.render(context, createViewportInfo(scene, cacheCanvas, {
+ diffBounds: [createBound(440, 0, 460, 280)],
+ diffCacheBounds: [],
+ diffX: fractional === 'distance' ? -20.5 : -20,
+ diffY: 0,
+ isDirty: 0,
+ isForceDirty: false,
+ shouldCacheUpdate: 0,
+ }));
+ expect(skeleton.stylesCache.fontMatrix.getValue(2, 2)).toBeDefined();
+ expect(prepareFont).not.toHaveBeenCalled();
+ expect(renderFont.mock.calls.some(([, row, col]) => row === 2 && col === 2)).toBe(true);
+ });
+
+ it.each([
+ { from: 69, to: 38.7, scale: 1.5, y: 11.25, reported: -20, expected: -30 },
+ { from: -287.15, to: -287.5, scale: 0.5, y: 0, reported: -2, expected: 0 },
+ { from: -287.5, to: -287.7, scale: 1, y: 0, reported: 0, expected: -1 },
+ ])('moves cached pixels by the actual raster origin: $from to $to at $scale', ({ from, to, scale, y, reported, expected }) => {
+ const { spreadsheet, skeleton, viewport, scene, mainCanvas } = fixture;
+ const canvas = viewport.canvas!;
+ canvas.setSize(700, 420, 1);
+ const ctx = mainCanvas.getContext();
+ ctx.setTransform(scale, 0, 0, scale, from, y);
+ spreadsheet.renderByViewports(ctx, createViewportInfo(scene, canvas), skeleton);
+ spreadsheet.makeDirty(false);
+ spreadsheet.makeForceDirty(false);
+ ctx.setTransform(scale, 0, 0, scale, to, y);
+ const refresh = vi.spyOn(spreadsheet, 'refreshCacheCanvas');
+ const copyTarget = spreadsheet as unknown as { _copyCacheForScrolling(...args: unknown[]): void };
+ const copy = vi.spyOn(copyTarget, '_copyCacheForScrolling');
+ spreadsheet.renderByViewports(ctx, createViewportInfo(scene, viewport.canvas!, {
+ diffBounds: reported ? [createBound(400, 0, 420, 240)] : [],
+ diffCacheBounds: [],
+ diffX: reported,
+ diffY: 0,
+ isDirty: 0,
+ isForceDirty: false,
+ shouldCacheUpdate: 0,
+ }), skeleton);
+ expect(refresh).not.toHaveBeenCalled();
+ if (expected) {
+ expect(copy).toHaveBeenCalledWith(expect.anything(), canvas, expected, 0);
+ } else {
+ expect(copy).not.toHaveBeenCalled();
+ }
+ });
+
+ it.each(['x', 'y'])('keeps text repairs local when the native origin crosses a precision band on %s scroll', (axis) => {
+ const { spreadsheet, skeleton, viewport, scene, mainCanvas } = fixture;
+ const canvas = viewport.canvas!;
+ canvas.setSize(700, 420, 1);
+ const ctx = mainCanvas.getContext();
+ ctx.setTransform(12, 0, 0, 12, axis === 'x' ? 1056 : 0, axis === 'y' ? 1104 : 0);
+ spreadsheet.renderByViewports(ctx, createViewportInfo(scene, canvas), skeleton);
+ ctx.setTransform(12, 0, 0, 12, axis === 'x' ? 410 : 0, axis === 'y' ? 458 : 0);
+ const info = createViewportInfo(scene, viewport.canvas!, {
+ diffBounds: [axis === 'x' ? createBound(400, 0, 420, 240) : createBound(0, 220, 420, 240)],
+ diffCacheBounds: [],
+ diffX: axis === 'x' ? -646 / 12 : 0,
+ diffY: axis === 'y' ? -646 / 12 : 0,
+ shouldCacheUpdate: 0,
+ isDirty: 0,
+ });
+ const repaint = spreadsheet as unknown as {
+ _getRepaintBounds(info: IViewportInfo, merges: IBoundRectNoAngle[], context: typeof ctx): { bound: IBoundRectNoAngle }[];
+ };
+ const nativeClipRanges = vi.spyOn(spreadsheet.getExtensionByKey('DefaultFontExtension') as Font, 'getNativeTextClipRepairRanges');
+ const bounds = repaint._getRepaintBounds(info, [], ctx);
+ expect(bounds).toEqual([]);
+ expect(nativeClipRanges).not.toHaveBeenCalled();
+ const point = axis === 'x' ? { x: 142, y: 40 } : { x: 82, y: 112 };
+ expect(bounds.some(({ bound }) => bound.left < point.x && bound.right > point.x
+ && bound.top < point.y && bound.bottom > point.y)).toBe(false);
+ // Panning over existing buffer pixels needs no refill; actual exposed cache pixels still do.
+ const refillBounds = repaint._getRepaintBounds({
+ ...info,
+ shouldCacheUpdate: 1,
+ diffCacheBounds: info.diffBounds,
+ }, [], ctx);
+ expect(nativeClipRanges).toHaveBeenCalledOnce();
+ const exposedPoint = axis === 'x' ? { x: 410, y: 40 } : { x: 82, y: 230 };
+ expect(refillBounds.some(({ bound }) => bound.left < exposedPoint.x && bound.right > exposedPoint.x
+ && bound.top < exposedPoint.y && bound.bottom > exposedPoint.y)).toBe(true);
+ const repairedArea = refillBounds.reduce((area, { bound }) => area + (bound.right - bound.left) * (bound.bottom - bound.top), 0);
+ const cacheArea = (info.cacheBound.right - info.cacheBound.left) * (info.cacheBound.bottom - info.cacheBound.top);
+ expect(repairedArea).toBeLessThan(cacheArea * 0.2);
+ });
+
+ it.each(['x', 'y'])('keeps retained cells cached within a stable native precision band on %s scroll', (axis) => {
+ const { spreadsheet, skeleton, viewport, scene, mainCanvas } = fixture;
+ const canvas = viewport.canvas!;
+ canvas.setSize(700, 420, 1);
+ const ctx = mainCanvas.getContext();
+ ctx.setTransform(12, 0, 0, 12, 9856, 9904);
+ spreadsheet.renderByViewports(ctx, createViewportInfo(scene, canvas), skeleton);
+ ctx.setTransform(12, 0, 0, 12, axis === 'x' ? 9844 : 9856, axis === 'y' ? 9892 : 9904);
+ const info = createViewportInfo(scene, viewport.canvas!, {
+ diffBounds: [axis === 'x' ? createBound(400, 0, 420, 240) : createBound(0, 220, 420, 240)],
+ diffCacheBounds: [],
+ diffX: axis === 'x' ? -1 : 0,
+ diffY: axis === 'y' ? -1 : 0,
+ shouldCacheUpdate: 0,
+ isDirty: 0,
+ });
+ const repaint = spreadsheet as unknown as {
+ _getRepaintBounds(info: IViewportInfo, merges: IBoundRectNoAngle[], context: typeof ctx): { bound: IBoundRectNoAngle }[];
+ };
+ expect(repaint._getRepaintBounds(info, [], ctx).some(({ bound }) => bound.left < 142 && bound.right > 142
+ && bound.top < 40 && bound.bottom > 40)).toBe(false);
+ });
+
+ it('keeps native rotated glyphs whole when a repair halo touches their cell clip', () => {
+ const { spreadsheet, skeleton, viewport, scene, mainCanvas } = fixture;
+ const canvas = viewport.canvas!;
+ canvas.setSize(700, 420, 1);
+ skeleton.setStylesCache(createViewportInfo(scene, canvas));
+ const ctx = mainCanvas.getContext();
+ ctx.setTransform(12, 0, 0, 12, 9856, 9904);
+ spreadsheet.renderByViewports(ctx, createViewportInfo(scene, canvas), skeleton);
+ ctx.setTransform(12, 0, 0, 12, 9856, 9892);
+ const info = createViewportInfo(scene, viewport.canvas!, {
+ diffBounds: [createBound(117.9, 51.9, 125, 60)],
+ diffCacheBounds: [createBound(117.9, 51.9, 125, 60)],
+ diffX: 0,
+ diffY: -1,
+ shouldCacheUpdate: 1,
+ isDirty: 0,
+ });
+ const repaint = spreadsheet as unknown as {
+ _getRepaintBounds(info: IViewportInfo, merges: IBoundRectNoAngle[], context: typeof ctx): { bound: IBoundRectNoAngle }[];
+ };
+ expect(repaint._getRepaintBounds(info, [], ctx).some(({ bound }) => bound.left < 142 && bound.right > 142
+ && bound.top < 75 && bound.bottom > 75)).toBe(true);
+ });
+
+ it('keeps the full native cell clip when a repair halo reaches shrink-to-fit text', () => {
+ const { spreadsheet, skeleton, viewport, scene, mainCanvas, workbook } = fixture;
+ const canvas = viewport.canvas!;
+ canvas.setSize(700, 420, 1);
+ const worksheet = workbook.getActiveSheet()!;
+ const cell = worksheet.getCell(0, 3)!;
+ vi.spyOn(FontCache, 'getMeasureText').mockReturnValue({ width: 240 } as TextMetrics);
+ skeleton._setFontStylesCache(0, 3, cell, worksheet.getComposedCellStyleByCellData(0, 3, cell)!);
+ skeleton.setStylesCache(createViewportInfo(scene, canvas));
+ expect(skeleton.stylesCache.fontMatrix.getValue(0, 3)?.shrinkScale).toBeLessThan(1);
+ const ctx = mainCanvas.getContext();
+ ctx.setTransform(12, 0, 0, 12, 9856, 9904);
+ spreadsheet.renderByViewports(ctx, createViewportInfo(scene, canvas), skeleton);
+ ctx.setTransform(12, 0, 0, 12, 9856, 9892);
+ const info = createViewportInfo(scene, viewport.canvas!, {
+ diffBounds: [createBound(229.9, 28, 240, 40)],
+ diffCacheBounds: [createBound(229.9, 28, 240, 40)],
+ diffX: 0,
+ diffY: -1,
+ shouldCacheUpdate: 1,
+ isDirty: 0,
+ });
+ const repaint = spreadsheet as unknown as {
+ _getRepaintBounds(info: IViewportInfo, merges: IBoundRectNoAngle[], context: typeof ctx): { bound: IBoundRectNoAngle }[];
+ };
+ expect(repaint._getRepaintBounds(info, [], ctx).some(({ bound }) => bound.left < 290 && bound.right > 290
+ && bound.top < 40 && bound.bottom > 40)).toBe(true);
+ });
+
+ it.each([SHEET_VIEWPORT_KEY.VIEW_MAIN_LEFT, SHEET_VIEWPORT_KEY.VIEW_MAIN_TOP])(
+ 'preserves native fixed-edge coverage when text repair reaches %s',
+ (viewportKey) => {
+ const { spreadsheet, skeleton, viewport, scene, mainCanvas } = fixture;
+ const getViewport = scene.getViewport.bind(scene);
+ vi.spyOn(scene, 'getViewport').mockImplementation((key) => key === viewportKey ? viewport : getViewport(key));
+ const canvas = viewport.canvas!;
+ canvas.setSize(700, 420, 1);
+ skeleton.setStylesCache(createViewportInfo(scene, canvas));
+ const ctx = mainCanvas.getContext();
+ const vertical = viewportKey === SHEET_VIEWPORT_KEY.VIEW_MAIN_LEFT;
+ const bounds = vertical ? createBound(118, 28, 166, 240) : createBound(46, 52, 302, 76);
+ const initial = createViewportInfo(scene, canvas, {
+ viewportKey,
+ viewBound: bounds,
+ cacheBound: bounds,
+ bufferEdgeX: 0,
+ bufferEdgeY: 0,
+ });
+ spreadsheet.renderByViewports(ctx, initial, skeleton);
+ spreadsheet.makeDirty(false);
+ spreadsheet.makeForceDirty(false);
+ ctx.translate(vertical ? 0 : -10, vertical ? -10 : 0);
+ const refresh = vi.spyOn(spreadsheet, 'refreshCacheCanvas');
+ const paint = vi.spyOn(spreadsheet, 'paintNewAreaForScrolling');
+ spreadsheet.renderByViewports(ctx, {
+ ...initial,
+ diffX: vertical ? 0 : -10,
+ diffY: vertical ? -10 : 0,
+ diffBounds: [vertical ? createBound(118, 51.9, 166, 60) : createBound(117.9, 52, 125, 76)],
+ diffCacheBounds: [vertical ? createBound(118, 51.9, 166, 60) : createBound(117.9, 52, 125, 76)],
+ isDirty: 0,
+ isForceDirty: false,
+ shouldCacheUpdate: 1,
+ }, skeleton);
+ expect(refresh).toHaveBeenCalledOnce();
+ expect(paint).not.toHaveBeenCalled();
+ }
+ );
+
+ it('rebuilds style coverage after a range reset even when the viewport stays in place', () => {
+ const { skeleton, scene, cacheCanvas } = fixture;
+ const info = createViewportInfo(scene, cacheCanvas);
+ skeleton.setStylesCache(info, { scaleY: 1 });
+ skeleton.resetRangeCache([{ startRow: 2, endRow: 3, startColumn: 2, endColumn: 3 }]);
+ const cell = skeleton.worksheet.getCellRaw(2, 2)!;
+ skeleton.worksheet.getCellMatrix().setValue(2, 2, { ...cell, v: 'Updated merge' });
+ skeleton.setStylesCache({ ...info, isDirty: 0, shouldCacheUpdate: 0, diffX: -0.2 }, { scaleY: 1 });
+ expect(skeleton.stylesCache.fontMatrix.getValue(2, 2)?.cellData?.v).toBe('Updated merge');
+ });
+
+ it.each(['scale', 'size', 'pixel-ratio', 'untracked-origin', 'fractional-viewport'])('refreshes an existing bitmap after its %s changes', (change) => {
+ const { spreadsheet, skeleton, viewport, scene, mainCanvas } = fixture;
+ const canvas = viewport.canvas!;
+ canvas.setSize(700, 420, 1);
+ const ctx = mainCanvas.getContext();
+ spreadsheet.renderByViewports(ctx, createViewportInfo(scene, canvas), skeleton);
+ spreadsheet.makeDirty(false);
+ spreadsheet.makeForceDirty(false);
+ if (change === 'scale') {
+ ctx.setTransform(2, 0, 0, 2, 0, 0);
+ } else if (change === 'untracked-origin' || change === 'fractional-viewport') {
+ ctx.translate(-4, 0);
+ } else {
+ canvas.setSize(change === 'size' ? 710 : 700, 420, change === 'pixel-ratio' ? 2 : 1);
+ }
+ const refresh = vi.spyOn(spreadsheet, 'refreshCacheCanvas');
+ spreadsheet.renderByViewports(ctx, createViewportInfo(scene, canvas, {
+ diffX: change === 'fractional-viewport' ? -4 : 0,
+ viewPortPosition: createBound(change === 'fractional-viewport' ? 0.25 : 0, 0, 420, 240),
+ isDirty: 0,
+ isForceDirty: false,
+ shouldCacheUpdate: 0,
+ }), skeleton);
+ expect(refresh).toHaveBeenCalledOnce();
+ });
+
+ it.each([
+ { zoom: 0.3333, pixelRatio: 3 },
+ { zoom: 0.67, pixelRatio: 1.25 },
+ { zoom: 0.9, pixelRatio: 2 },
+ { zoom: 1.1, pixelRatio: 2 },
+ { zoom: 1.25, pixelRatio: 3 },
+ { zoom: 4, pixelRatio: 1.25 },
+ ])('reuses stable fractional viewport pixels at zoom $zoom and DPR $pixelRatio', ({ zoom, pixelRatio }) => {
+ const { spreadsheet, skeleton, viewport, scene, mainCanvas } = fixture;
+ const canvas = viewport.canvas!;
+ canvas.setSize(700, 420, pixelRatio);
+ const ctx = mainCanvas.getContext();
+ const scale = zoom * pixelRatio;
+ const position = createBound(46 * zoom, 24 * zoom, 420, 240);
+ ctx.setTransform(scale, 0, 0, scale, 0, 0);
+ spreadsheet.renderByViewports(ctx, createViewportInfo(scene, canvas, { viewPortPosition: position }), skeleton);
+ spreadsheet.makeDirty(false);
+ spreadsheet.makeForceDirty(false);
+
+ const refresh = vi.spyOn(spreadsheet, 'refreshCacheCanvas');
+ const paint = vi.spyOn(spreadsheet, 'paintNewAreaForScrolling');
+ ctx.setTransform(scale, 0, 0, scale, -10.2 * scale, 0);
+ spreadsheet.renderByViewports(ctx, createViewportInfo(scene, viewport.canvas!, {
+ viewPortPosition: position,
+ diffX: -10.2,
+ diffBounds: [createBound(400, 0, 420, 240)],
+ diffCacheBounds: [createBound(400, 0, 460, 280)],
+ isDirty: 0,
+ isForceDirty: false,
+ shouldCacheUpdate: 1,
+ }), skeleton);
+ expect(refresh).not.toHaveBeenCalled();
+ expect(paint).toHaveBeenCalledOnce();
+ });
+
+ it.each([
+ { zoom: 1.33, pixelRatio: 2 },
+ { zoom: 1.34, pixelRatio: 2 },
+ { zoom: 1.35, pixelRatio: 2 },
+ { zoom: 1.33, pixelRatio: 3 },
+ { zoom: 1.34, pixelRatio: 3 },
+ { zoom: 1.35, pixelRatio: 3 },
+ ].flatMap((scale) => ['x', 'y'].map((axis) => ({ ...scale, axis }))))(
+ 'preserves the one-pixel scroll allowance with Float32 canvas scales at $zoom / $pixelRatio on $axis',
+ ({ zoom, pixelRatio, axis }) => {
+ const { spreadsheet, skeleton, viewport, scene, mainCanvas } = fixture;
+ const canvas = viewport.canvas!;
+ canvas.setSize(700, 700, pixelRatio);
+ scene.setScaleValueOnly(zoom, zoom);
+ const ctx = mainCanvas.getContext();
+ const logicalScale = zoom * pixelRatio;
+ const nativeScale = Math.fround(logicalScale);
+ const position = createBound(46 * zoom, 24 * zoom, 420, 240);
+ ctx.setTransform(nativeScale, 0, 0, nativeScale, 0, 0);
+ spreadsheet.renderByViewports(ctx, createViewportInfo(scene, canvas, { viewPortPosition: position }), skeleton);
+ spreadsheet.makeDirty(false);
+ spreadsheet.makeForceDirty(false);
+
+ const refresh = vi.spyOn(spreadsheet, 'refreshCacheCanvas');
+ const paint = vi.spyOn(spreadsheet, 'paintNewAreaForScrolling');
+ const displacement = nativeScale > logicalScale ? -999 : -1001;
+ ctx.setTransform(nativeScale, 0, 0, nativeScale, axis === 'x' ? displacement : 0, axis === 'y' ? displacement : 0);
+ spreadsheet.renderByViewports(ctx, createViewportInfo(scene, viewport.canvas!, {
+ viewPortPosition: position,
+ diffX: axis === 'x' ? -1000 / logicalScale : 0,
+ diffY: axis === 'y' ? -1000 / logicalScale : 0,
+ diffBounds: [createBound(400, 200, 420, 240)],
+ diffCacheBounds: [createBound(400, 200, 460, 280)],
+ isDirty: 0,
+ isForceDirty: false,
+ shouldCacheUpdate: 1,
+ }), skeleton);
+ expect(refresh).not.toHaveBeenCalled();
+ expect(paint).toHaveBeenCalledOnce();
+ }
+ );
+
+ it.each(['unmatched-transform', 'larger-displacement'])(
+ 'retains scroll-cache rejection for $0 after Float32 scale normalization',
+ (reason) => {
+ const { spreadsheet, skeleton, viewport, scene, mainCanvas } = fixture;
+ const canvas = viewport.canvas!;
+ canvas.setSize(700, 700, 2);
+ scene.setScaleValueOnly(reason === 'unmatched-transform' ? 1.35 : 1.34, 1.34);
+ const ctx = mainCanvas.getContext();
+ const nativeScale = Math.fround(2.68);
+ ctx.setTransform(nativeScale, 0, 0, nativeScale, 0, 0);
+ spreadsheet.renderByViewports(ctx, createViewportInfo(scene, canvas), skeleton);
+ spreadsheet.makeDirty(false);
+ spreadsheet.makeForceDirty(false);
+
+ const refresh = vi.spyOn(spreadsheet, 'refreshCacheCanvas');
+ const paint = vi.spyOn(spreadsheet, 'paintNewAreaForScrolling');
+ ctx.setTransform(nativeScale, 0, 0, nativeScale, reason === 'larger-displacement' ? -998 : -999, 0);
+ spreadsheet.renderByViewports(ctx, createViewportInfo(scene, viewport.canvas!, {
+ diffX: -1000 / 2.68,
+ diffBounds: [createBound(400, 200, 420, 240)],
+ diffCacheBounds: [createBound(400, 200, 460, 280)],
+ isDirty: 0,
+ isForceDirty: false,
+ shouldCacheUpdate: 1,
+ }), skeleton);
+ expect(refresh).toHaveBeenCalledOnce();
+ expect(paint).not.toHaveBeenCalled();
+ }
+ );
+
+ it('retains full repaint for simultaneous axes at a fractional viewport edge', () => {
+ const { spreadsheet, skeleton, viewport, scene, mainCanvas } = fixture;
+ const canvas = viewport.canvas!;
+ canvas.setSize(700, 420, 2);
+ const ctx = mainCanvas.getContext();
+ const position = createBound(41.4, 21.6, 420, 240);
+ ctx.setTransform(1.8, 0, 0, 1.8, 0, 0);
+ spreadsheet.renderByViewports(ctx, createViewportInfo(scene, canvas, { viewPortPosition: position }), skeleton);
+ spreadsheet.makeDirty(false);
+ spreadsheet.makeForceDirty(false);
+
+ const refresh = vi.spyOn(spreadsheet, 'refreshCacheCanvas');
+ const paint = vi.spyOn(spreadsheet, 'paintNewAreaForScrolling');
+ ctx.setTransform(1.8, 0, 0, 1.8, -18, -18);
+ spreadsheet.renderByViewports(ctx, createViewportInfo(scene, canvas, {
+ viewPortPosition: position,
+ diffX: -10,
+ diffY: -10,
+ diffBounds: [createBound(400, 0, 420, 240)],
+ diffCacheBounds: [createBound(400, 0, 460, 280)],
+ isDirty: 0,
+ isForceDirty: false,
+ shouldCacheUpdate: 1,
+ }), skeleton);
+ expect(refresh).toHaveBeenCalledOnce();
+ expect(paint).not.toHaveBeenCalled();
+ });
+
+ it('retains full repaint for horizontal scrolling in a fractionally clipped frozen row band', () => {
+ const { spreadsheet, skeleton, viewport, scene, mainCanvas } = fixture;
+ const getViewport = scene.getViewport.bind(scene);
+ vi.spyOn(scene, 'getViewport').mockImplementation((key) => key === SHEET_VIEWPORT_KEY.VIEW_MAIN_TOP ? viewport : getViewport(key));
+ const canvas = viewport.canvas!;
+ canvas.setSize(700, 420, 3);
+ const ctx = mainCanvas.getContext();
+ const position = createBound(77, 12, 420, 49.5);
+ ctx.setTransform(1.5, 0, 0, 1.5, 0, 0);
+ spreadsheet.renderByViewports(ctx, createViewportInfo(scene, canvas, {
+ viewportKey: SHEET_VIEWPORT_KEY.VIEW_MAIN_TOP,
+ viewPortPosition: position,
+ }), skeleton);
+ spreadsheet.makeDirty(false);
+ spreadsheet.makeForceDirty(false);
+
+ const refresh = vi.spyOn(spreadsheet, 'refreshCacheCanvas');
+ const paint = vi.spyOn(spreadsheet, 'paintNewAreaForScrolling');
+ ctx.setTransform(1.5, 0, 0, 1.5, -15, 0);
+ spreadsheet.renderByViewports(ctx, createViewportInfo(scene, canvas, {
+ viewportKey: SHEET_VIEWPORT_KEY.VIEW_MAIN_TOP,
+ viewPortPosition: position,
+ diffX: -10,
+ diffY: 0,
+ diffBounds: [createBound(400, 0, 420, 240)],
+ diffCacheBounds: [createBound(400, 0, 460, 280)],
+ isDirty: 0,
+ isForceDirty: false,
+ shouldCacheUpdate: 1,
+ }), skeleton);
+ expect(refresh).toHaveBeenCalledOnce();
+ expect(paint).not.toHaveBeenCalled();
+ });
+
+ it('prepares missing style coverage independently of the bitmap damage strips', () => {
+ const { skeleton, scene, cacheCanvas } = fixture;
+ skeleton.setStylesCache(createViewportInfo(scene, cacheCanvas, { cacheBound: createBound(0, 0, 300, 280) }));
+ expect(skeleton.stylesCache.backgroundPositions?.getValue(0, 4)).toBeUndefined();
+ skeleton.setStylesCache(createViewportInfo(scene, cacheCanvas, {
+ cacheBound: createBound(72, 0, 460, 280),
+ diffX: -72,
+ isDirty: 0,
+ isForceDirty: false,
+ shouldCacheUpdate: 0,
+ }));
+ expect(skeleton.stylesCache.backgroundPositions?.getValue(0, 4)).toBeDefined();
+ });
+
+ it('batches styles at the cache boundary while the prepared range covers the visible cells', () => {
+ const { skeleton, scene, cacheCanvas } = fixture;
+ skeleton.setStylesCache(createViewportInfo(scene, cacheCanvas, {
+ cacheBound: createBound(0, 0, 300, 280),
+ viewBound: createBound(46, 28, 250, 240),
+ }));
+ const info = createViewportInfo(scene, cacheCanvas, {
+ cacheBound: createBound(20, 0, 320, 280),
+ viewBound: createBound(66, 28, 270, 240),
+ diffX: -20,
+ isDirty: 0,
+ isForceDirty: false,
+ shouldCacheUpdate: 0,
+ });
+ const prepareFont = vi.spyOn(skeleton, '_setFontStylesCache');
+ skeleton.setStylesCache(info);
+ expect(prepareFont).not.toHaveBeenCalled();
+ expect(skeleton.stylesCache.backgroundPositions?.getValue(0, 4)).toBeUndefined();
+ skeleton.setStylesCache({ ...info, shouldCacheUpdate: 1 });
+ expect(skeleton.stylesCache.backgroundPositions?.getValue(0, 4)).toBeDefined();
+ });
+
+ it('keeps full and incremental raster origins integral at non-binary zooms', () => {
+ const { spreadsheet, skeleton, viewport, scene, mainCanvas } = fixture;
+ const canvas = viewport.canvas!;
+ canvas.setSize(700, 420, 1);
+ const ctx = mainCanvas.getContext();
+ const origins: { left: number; top: number }[] = [];
+ const draw = spreadsheet.draw.bind(spreadsheet);
+ vi.spyOn(spreadsheet, 'draw').mockImplementation((context, info, repair) => {
+ const transform = context.getTransform();
+ origins.push({ left: transform.e, top: transform.f });
+ return draw(context, info, repair);
+ });
+ ctx.setTransform(2.01, 0, 0, 2.01, -387.123, 20.7);
+ spreadsheet.renderByViewports(ctx, createViewportInfo(scene, canvas), skeleton);
+ spreadsheet.makeDirty(false);
+ spreadsheet.makeForceDirty(false);
+ ctx.setTransform(2.01, 0, 0, 2.01, -407.4, 20.7);
+ spreadsheet.renderByViewports(ctx, createViewportInfo(scene, viewport.canvas!, {
+ diffX: -10.09,
+ diffY: 0,
+ diffBounds: [createBound(400, 0, 420, 240)],
+ diffCacheBounds: [createBound(400, 0, 460, 280)],
+ isDirty: 0,
+ isForceDirty: false,
+ shouldCacheUpdate: 1,
+ }), skeleton);
+ expect(origins.length).toBeGreaterThan(1);
+ expect(origins.every(({ left, top }) => Number.isInteger(left) && Number.isInteger(top))).toBe(true);
+ });
+
+ it('uses independent viewport buffers to repaint only newly exposed horizontal cache strips', () => {
+ const { spreadsheet, skeleton, mainCanvas, viewport, scene } = fixture;
+ const cacheCanvas = viewport.canvas!;
+ cacheCanvas.setSize(700, 420, 1);
+ const viewportInfo = createViewportInfo(scene, cacheCanvas, {
+ diffBounds: [createBound(440, 0, 460, 280)],
+ diffCacheBounds: [createBound(400, 0, 460, 280)],
+ diffX: -20,
+ diffY: 0,
+ isDirty: 0,
+ isForceDirty: false,
+ shouldCacheUpdate: 1,
+ });
+ spreadsheet.makeDirty(false);
+ spreadsheet.makeForceDirty(false);
+ const paint = vi.spyOn(spreadsheet, 'paintNewAreaForScrolling');
+ const refresh = vi.spyOn(spreadsheet, 'refreshCacheCanvas');
+ spreadsheet.render(mainCanvas.getContext(), viewportInfo);
+ expect(refresh).not.toHaveBeenCalled();
+ expect(paint).toHaveBeenCalledOnce();
+ expect(viewport.canvas).not.toBe(cacheCanvas);
+ });
+
+ it.each([
+ { key: SHEET_VIEWPORT_KEY.VIEW_MAIN_LEFT, width: 32.16, full: true },
+ { key: SHEET_VIEWPORT_KEY.VIEW_MAIN_LEFT, width: 32, full: false },
+ { key: SHEET_VIEWPORT_KEY.VIEW_MAIN, width: 32.16, full: false },
+ ])('protects a fractional frozen edge without broadening main viewport refresh: $key $width', ({ key, width, full }) => {
+ const { spreadsheet, skeleton, mainCanvas, cacheCanvas, scene } = fixture;
+ const info = createViewportInfo(scene, cacheCanvas, {
+ viewportKey: key,
+ viewPortPosition: createBound(0, 0, width, 240),
+ diffY: -10,
+ diffBounds: [createBound(0, 240, 420, 250)],
+ diffCacheBounds: [createBound(0, 240, 460, 280)],
+ isDirty: 0,
+ isForceDirty: false,
+ shouldCacheUpdate: 1,
+ });
+ skeleton.setStylesCache(info);
+ spreadsheet.makeDirty(false);
+ spreadsheet.makeForceDirty(false);
+ const refresh = vi.spyOn(spreadsheet, 'refreshCacheCanvas');
+ const paint = vi.spyOn(spreadsheet, 'paintNewAreaForScrolling');
+ spreadsheet.renderByViewports(mainCanvas.getContext(), info, skeleton);
+ expect(refresh).toHaveBeenCalledTimes(full ? 1 : 0);
+ expect(paint).toHaveBeenCalledTimes(full ? 0 : 1);
+ });
+
+ it.each(['dirty', 'force', 'fractional', 'within-buffer-fractional', 'fractional-origin', 'within-buffer-fractional-origin', 'missing-strip', 'jump'])('retains the horizontal full-refresh fallback for %s', (reason) => {
+ const { spreadsheet, skeleton, mainCanvas, viewport, scene } = fixture;
+ const cacheCanvas = viewport.canvas!;
+ cacheCanvas.setSize(700, 420, 1);
+ const viewportInfo = createViewportInfo(scene, cacheCanvas, {
+ diffBounds: [createBound(440, 0, 460, 280)],
+ diffCacheBounds: reason === 'missing-strip' ? [] : [createBound(400, 0, 460, 280)],
+ diffX: reason.endsWith('fractional') ? -20.5 : -20,
+ diffY: 0,
+ isDirty: reason === 'dirty' ? 1 : 0,
+ isForceDirty: reason === 'force',
+ shouldCacheUpdate: reason.startsWith('within-buffer') ? 0 : 1,
+ });
+ if (reason === 'jump') {
+ viewportInfo.diffX = -10000;
+ }
+ spreadsheet.makeDirty(false);
+ spreadsheet.makeForceDirty(false);
+ if (reason.endsWith('fractional-origin')) {
+ mainCanvas.getContext().translate(0.5, 0);
+ }
+ const refresh = vi.spyOn(spreadsheet, 'refreshCacheCanvas');
+ const paint = vi.spyOn(spreadsheet, 'paintNewAreaForScrolling');
+ spreadsheet.renderByViewports(mainCanvas.getContext(), viewportInfo, skeleton);
+ expect(refresh).toHaveBeenCalledOnce();
+ expect(paint).not.toHaveBeenCalled();
+ });
+
+ it.each([
+ { axis: 'row', index: 0, size: 32, diffX: -20, diffY: 0, update: 1, full: true },
+ { axis: 'row', index: 0, size: 32, diffX: -20, diffY: 0, update: 0, full: true },
+ { axis: 'column', index: 0, size: 16, diffX: 0, diffY: -20, update: 1, full: true },
+ { axis: 'column', index: 0, size: 16, diffX: 0, diffY: -20, update: 0, full: true },
+ { axis: 'row', index: 19, size: 32, diffX: -20, diffY: 0, update: 1, full: false },
+ { axis: 'column', index: 11, size: 16, diffX: 0, diffY: -20, update: 1, full: false },
+ { axis: 'row', index: 0, size: 32, diffX: 0, diffY: -20, update: 1, full: false },
+ { axis: 'column', index: 0, size: 16, diffX: -20, diffY: 0, update: 1, full: false },
+ { axis: 'row', index: 0, size: 0, diffX: -20, diffY: 0, update: 1, full: false },
+ ])('preserves gap stripe phase on $axis scrolls (gap: $index, cache update: $update)', ({ axis, index, size, diffX, diffY, update, full }) => {
+ const { spreadsheet, skeleton, mainCanvas, viewport, scene } = fixture;
+ const cacheCanvas = viewport.canvas!;
+ cacheCanvas.setSize(700, 420, 1);
+ skeleton.setGapConfig(axis === 'row'
+ ? { rowGaps: { [index]: { size } } }
+ : { colGaps: { [index]: { size } } });
+ const info = createViewportInfo(scene, cacheCanvas, {
+ diffBounds: [diffX ? createBound(400, 0, 420, 240) : createBound(0, 220, 420, 240)],
+ diffCacheBounds: update ? [diffX ? createBound(400, 0, 460, 280) : createBound(0, 220, 460, 280)] : [],
+ diffX,
+ diffY,
+ isDirty: 0,
+ isForceDirty: false,
+ shouldCacheUpdate: update,
+ });
+ skeleton.setStylesCache(info);
+ spreadsheet.makeDirty(false);
+ spreadsheet.makeForceDirty(false);
+ const refresh = vi.spyOn(spreadsheet, 'refreshCacheCanvas');
+ const paint = vi.spyOn(spreadsheet, 'paintNewAreaForScrolling');
+
+ spreadsheet.renderByViewports(mainCanvas.getContext(), info, skeleton);
+
+ expect(refresh).toHaveBeenCalledTimes(full ? 1 : 0);
+ expect(paint).toHaveBeenCalledTimes(full ? 0 : 1);
+ });
+
+ it('retains full horizontal refresh when the cache is not owned by the viewport', () => {
const { spreadsheet, skeleton, mainCanvas, cacheCanvas, scene } = fixture;
const context = mainCanvas.getContext();
const viewportInfo = createViewportInfo(scene, cacheCanvas, {
@@ -1446,12 +2939,54 @@ describe('spreadsheet integration', () => {
);
});
+ it.each([
+ { browser: 'Safari', iPhone: false, swaps: false },
+ { browser: 'Chrome', iPhone: true, swaps: false },
+ { browser: 'Chrome', iPhone: false, swaps: true },
+ { browser: 'FF', iPhone: false, swaps: true },
+ ])('preserves native text context on $browser (iPhone: $iPhone)', ({ browser, iPhone, swaps }) => {
+ const { spreadsheet, skeleton, scene, viewport, mainCanvas } = fixture;
+ const mainCtx = mainCanvas.getContext();
+ vi.spyOn(mainCtx, 'getBrowserType').mockReturnValue(browser);
+ vi.spyOn(Tools, 'isIPhone').mockReturnValue(iPhone);
+ const initialCanvas = viewport.canvas!;
+ initialCanvas.setSize(460, 280, 1);
+ let source = initialCanvas;
+
+ for (const direction of [1, -1]) {
+ const next = spreadsheet.paintNewAreaForScrolling(
+ createViewportInfo(scene, source, {
+ diffX: direction * 4,
+ diffY: direction * 3,
+ diffBounds: [createBound(100, 60, 220, 140)],
+ diffCacheBounds: [createBound(100, 60, 220, 140)],
+ }),
+ {
+ cacheCanvas: source,
+ cacheCtx: source.getContext(),
+ mainCtx,
+ topOrigin: 0,
+ leftOrigin: 0,
+ bufferEdgeX: 8,
+ bufferEdgeY: 6,
+ rowHeaderWidthAndMarginLeft: skeleton.rowHeaderWidthAndMarginLeft,
+ columnHeaderHeightAndMarginTop: skeleton.columnHeaderHeightAndMarginTop,
+ scaleX: 1,
+ scaleY: 1,
+ }
+ );
+ expect(next === source).toBe(!swaps);
+ expect(viewport.canvas).toBe(next);
+ source = next;
+ }
+ });
+
it('alternates scroll buffers independently for each viewport', () => {
const { spreadsheet, skeleton, scene, viewport, mainCanvas } = fixture;
const mainCtx = mainCanvas.getContext() as any;
const mainCache = viewport.canvas!;
mainCache.setSize(460, 280, 1);
- const frozenViewport = new Viewport(SHEET_VIEWPORT_KEY.VIEW_MAIN_LEFT, scene, {
+ const frozenViewport = fixture.univer.__getInjector().createInstance(Viewport, SHEET_VIEWPORT_KEY.VIEW_MAIN_LEFT, scene, {
left: 0,
top: 0,
width: 80,
diff --git a/packages/engine-render/src/components/sheets/column-header.ts b/packages/engine-render/src/components/sheets/column-header.ts
index 0478d70459..5bdff578da 100644
--- a/packages/engine-render/src/components/sheets/column-header.ts
+++ b/packages/engine-render/src/components/sheets/column-header.ts
@@ -49,6 +49,7 @@ export class SpreadsheetColumnHeader extends SpreadsheetHeader {
constructor(oKey: string, spreadsheetSkeleton?: SpreadsheetSkeleton) {
super(oKey, spreadsheetSkeleton);
+ this.viewportCacheReusable = this.constructor === SpreadsheetColumnHeader;
this._initialDefaultExtension();
this.makeDirty(true);
}
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 973db61252..81131f5116 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
@@ -14,349 +14,211 @@
* limitations under the License.
*/
-import { ObjectMatrix } from '@univerjs/core';
-import { describe, expect, it, vi } from 'vitest';
+import type { Injector, IWorkbookData, Workbook } from '@univerjs/core';
+import { BooleanNumber, ObjectMatrix, Univer, UniverInstanceType } from '@univerjs/core';
+import { afterEach, assert, beforeEach, describe, expect, it, vi } from 'vitest';
+import { UniverRenderingContext } from '../../../../context';
+import { SpreadsheetSkeleton } from '../../sheet.render-skeleton';
import { Background } from '../background';
+let univer: Univer;
+let injector: Injector;
+
function createCtx() {
- return {
- save: vi.fn(),
- restore: vi.fn(),
- beginPath: vi.fn(),
- closePath: vi.fn(),
- fill: vi.fn(),
- getScale: vi.fn(() => ({ scaleX: 1, scaleY: 1 })),
- fillStyle: '',
- } as any;
+ const ctx = injector.get(UniverRenderingContext);
+ vi.spyOn(ctx, 'fill');
+ return ctx;
}
-function createCellInfo(overrides?: Partial<any>) {
- return {
- row: 0,
- column: 0,
- startX: 0,
- startY: 0,
- endX: 10,
- endY: 20,
- isMerged: false,
- isMergedMainCell: false,
- mergeInfo: {
- startX: 0,
- startY: 0,
- endX: 10,
- endY: 20,
- startRow: 0,
- endRow: 0,
- startColumn: 0,
- endColumn: 0,
- },
- ...overrides,
- };
+function createCellInfo(overrides?: Partial<ReturnType<SpreadsheetSkeleton['getCellWithCoordByIndex']>>) {
+ return { ...injector.get(SpreadsheetSkeleton).getCellWithCoordByIndex(0, 0), ...overrides };
}
-function createBgMatrix(entries: Array<[number, number, string]>, size = entries.length) {
- const valueMap = new Map(entries.map((item) => [`${item[0]}-${item[1]}`, item[2]]));
- return {
- getValue: vi.fn((row: number, col: number) => valueMap.get(`${row}-${col}`)),
- forValue: vi.fn((cb: (row: number, col: number, value: string) => void) => {
- entries.forEach(([row, col, value]) => cb(row, col, value));
- }),
- getSizeOf: vi.fn(() => size),
- };
+function createBgMatrix(entries: Array<[number, number, string]>) {
+ const matrix = new ObjectMatrix<string>();
+ entries.forEach(([row, col, value]) => matrix.setValue(row, col, value));
+ vi.spyOn(matrix, 'forValue');
+ return matrix;
}
describe('background extension', () => {
- it('draws by view ranges and by matrix iteration', () => {
- const extension = new Background();
- const ctx = createCtx();
- const bgByRange = createBgMatrix([[0, 0, '1']], 99);
- const bgByMatrix = createBgMatrix([[0, 0, '1']], 1);
-
- const worksheet = {
- getMergedCellRange: vi.fn(() => []),
- getRowVisible: vi.fn(() => true),
- getColVisible: vi.fn(() => true),
- getSpanModel: vi.fn(() => ({
- getMergeDataIndex: vi.fn(() => -1),
- })),
- } as any;
+ beforeEach(() => {
+ univer = new Univer();
+ injector = univer.__getInjector();
+ const workbook = univer.createUnit<IWorkbookData, Workbook>(UniverInstanceType.UNIVER_SHEET, {
+ id: 'background-render',
+ sheetOrder: ['sheet'],
+ sheets: {
+ sheet: {
+ id: 'sheet',
+ rowCount: 60,
+ columnCount: 60,
+ defaultRowHeight: 20,
+ defaultColumnWidth: 40,
+ rowHeader: { width: 46, hidden: BooleanNumber.TRUE },
+ columnHeader: { height: 20, hidden: BooleanNumber.TRUE },
+ },
+ },
+ });
+ injector.add([Background]);
+ injector.add([SpreadsheetSkeleton, {
+ useFactory: function createSkeleton() {
+ return injector.createInstance(SpreadsheetSkeleton, workbook.getActiveSheet()!, workbook.getStyles());
+ },
+ }]);
+ injector.add([UniverRenderingContext, {
+ useFactory: function createContext() {
+ return injector.createInstance(UniverRenderingContext, document.createElement('canvas').getContext('2d')!);
+ },
+ }]);
+ });
- const skeletonBase = {
- worksheet,
- rowHeightAccumulation: [20],
- columnWidthAccumulation: [40],
- columnTotalWidth: 40,
- rowTotalHeight: 20,
- getCellWithCoordByIndex: vi.fn(() => createCellInfo()),
- };
+ afterEach(() => {
+ univer.dispose();
+ vi.restoreAllMocks();
+ });
- extension.draw(
- ctx,
- { scaleX: 1, scaleY: 1 } as any,
- {
- ...skeletonBase,
- stylesCache: {
- background: { '#ff0000': bgByRange },
- backgroundPositions: new ObjectMatrix(),
- },
- } as any,
- [],
- {
+ it('draws populated cells inside visible ranges across background colors', () => {
+ const extension = injector.get(Background);
+ const skeleton = injector.get(SpreadsheetSkeleton).calculate() as SpreadsheetSkeleton;
+ const ctx = createCtx();
+ const bgByRange = createBgMatrix([[0, 0, '1']]);
+ const bgByMatrix = createBgMatrix([[0, 0, '1'], [50, 50, '1']]);
+ const rendered = vi.spyOn(extension, 'renderBGByCell');
+ const backgroundPositions = skeleton.stylesCache.backgroundPositions;
+ assert.isDefined(backgroundPositions);
+ for (const [color, matrix] of [['#ff0000', bgByRange], ['#00ff00', bgByMatrix]] as const) {
+ skeleton.stylesCache.background = { [color]: matrix };
+ backgroundPositions.reset();
+ extension.draw(ctx, { scaleX: 1, scaleY: 1 }, skeleton, [], {
+ viewportKey: 'viewMain',
viewRanges: [{ startRow: 0, endRow: 1, startColumn: 0, endColumn: 1 }],
checkOutOfViewBound: true,
- } as any
- );
+ });
+ }
expect(bgByRange.forValue).not.toHaveBeenCalled();
+ expect(bgByMatrix.forValue).not.toHaveBeenCalled();
expect(ctx.fill).toHaveBeenCalled();
-
- extension.draw(
- ctx,
- { scaleX: 1, scaleY: 1 } as any,
- {
- ...skeletonBase,
- stylesCache: {
- background: { '#00ff00': bgByMatrix },
- backgroundPositions: new ObjectMatrix(),
- },
- } as any,
- [],
- {
- viewRanges: [{ startRow: 0, endRow: 1, startColumn: 0, endColumn: 1 }],
- checkOutOfViewBound: true,
- } as any
- );
- expect(bgByMatrix.forValue).toHaveBeenCalled();
+ expect(rendered).toHaveBeenCalledTimes(2);
+ expect(rendered.mock.calls.every(([, row, col]) => row === 0 && col === 0)).toBe(true);
});
it('reuses cached background cell positions when drawing backgrounds', () => {
- const extension = new Background();
+ const extension = injector.get(Background);
+ const skeleton = injector.get(SpreadsheetSkeleton).calculate() as SpreadsheetSkeleton;
const ctx = createCtx();
- const bgMatrix = createBgMatrix([[0, 0, '1']], 99);
- const backgroundPositions = new ObjectMatrix();
+ skeleton.stylesCache.background = { '#ff0000': createBgMatrix([[0, 0, '1']]) };
+ const backgroundPositions = skeleton.stylesCache.backgroundPositions;
+ assert.isDefined(backgroundPositions);
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,
- 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.getCellWithCoordByIndex).not.toHaveBeenCalled();
+ const coordinates = vi.spyOn(skeleton, 'getCellWithCoordByIndex');
+ extension.draw(ctx, { scaleX: 1, scaleY: 1 }, skeleton, [], {
+ viewportKey: 'viewMain',
+ viewRanges: [{ startRow: 0, endRow: 0, startColumn: 0, endColumn: 0 }],
+ checkOutOfViewBound: true,
+ });
+ expect(coordinates).not.toHaveBeenCalled();
expect(ctx.fill).toHaveBeenCalled();
});
it('skips merge lookups when drawing merge-free backgrounds', () => {
- const extension = new Background();
+ const extension = injector.get(Background);
+ const skeleton = injector.get(SpreadsheetSkeleton).calculate() as SpreadsheetSkeleton;
+ const worksheet = skeleton.worksheet;
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,
- 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();
+ skeleton.stylesCache.background = { '#ff0000': createBgMatrix([[0, 0, '1']]) };
+ const mergeDataIndex = vi.spyOn(worksheet.getSpanModel(), 'getMergeDataIndex');
+ const spanModel = vi.spyOn(worksheet, 'getSpanModel');
+ const mergeRanges = vi.spyOn(worksheet, 'getMergedCellRange');
+ extension.draw(ctx, { scaleX: 1, scaleY: 1 }, skeleton, [], {
+ viewportKey: 'viewMain',
+ viewRanges: [{ startRow: 0, endRow: 0, startColumn: 0, endColumn: 0 }],
+ checkOutOfViewBound: true,
+ hasMergeData: false,
+ });
+ expect(mergeRanges).not.toHaveBeenCalled();
+ expect(spanModel).not.toHaveBeenCalled();
+ expect(mergeDataIndex).not.toHaveBeenCalled();
expect(ctx.fill).toHaveBeenCalled();
});
it('uses diff ranges to choose background iteration during incremental drawing', () => {
- const extension = new Background();
+ const extension = injector.get(Background);
+ const skeleton = injector.get(SpreadsheetSkeleton).calculate() as SpreadsheetSkeleton;
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,
- 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
- );
-
+ const bgMatrix = createBgMatrix([[1, 1, '1']]);
+ skeleton.stylesCache.background = { '#ff0000': bgMatrix };
+ const coordinates = vi.spyOn(skeleton, 'getCellWithCoordByIndex');
+ extension.draw(ctx, { scaleX: 1, scaleY: 1 }, skeleton, [{ startRow: 1, endRow: 1, startColumn: 1, endColumn: 1 }], {
+ viewportKey: 'viewMain',
+ viewRanges: [{ startRow: 0, endRow: 1, startColumn: 0, endColumn: 1 }],
+ checkOutOfViewBound: true,
+ });
expect(bgMatrix.forValue).not.toHaveBeenCalled();
- expect(bgMatrix.getValue).toHaveBeenCalledWith(1, 1);
+ expect(coordinates).toHaveBeenCalledWith(1, 1, false);
});
it('draws merged cell backgrounds and handles early draw exits', () => {
- const extension = new Background();
+ const extension = injector.get(Background);
+ const skeleton = injector.get(SpreadsheetSkeleton).calculate() as SpreadsheetSkeleton;
const ctx = createCtx();
- const bgMatrix = createBgMatrix([[0, 0, '1']], 2);
- const mergedRange = { startRow: 0, endRow: 0, startColumn: 0, endColumn: 0 };
-
- const skeleton = {
- worksheet: {
- getMergedCellRange: vi.fn(() => [mergedRange]),
- getRowVisible: vi.fn(() => true),
- getColVisible: vi.fn(() => true),
- getSpanModel: vi.fn(() => ({
- getMergeDataIndex: vi.fn(() => -1),
- })),
- },
- stylesCache: {
- background: { '#112233': bgMatrix },
- backgroundPositions: new ObjectMatrix(),
- },
- rowHeightAccumulation: [20],
- columnWidthAccumulation: [40],
- columnTotalWidth: 40,
- rowTotalHeight: 20,
- getCellWithCoordByIndex: vi.fn(() => createCellInfo({ isMergedMainCell: true })),
- } as any;
-
- extension.draw(
- ctx,
- { scaleX: 1, scaleY: 1 } as any,
- skeleton,
- [],
- {
- viewRanges: [{ startRow: 0, endRow: 1, startColumn: 0, endColumn: 1 }],
- checkOutOfViewBound: true,
- } as any
- );
-
- expect(skeleton.getCellWithCoordByIndex).toHaveBeenCalled();
+ skeleton.worksheet.getSpanModel().add({ startRow: 0, endRow: 1, startColumn: 0, endColumn: 1 });
+ skeleton.stylesCache.background = { '#112233': createBgMatrix([[0, 0, '1']]) };
+ const coordinates = vi.spyOn(skeleton, 'getCellWithCoordByIndex');
+ extension.draw(ctx, { scaleX: 1, scaleY: 1 }, skeleton, [], {
+ viewportKey: 'viewMain',
+ viewRanges: [{ startRow: 0, endRow: 1, startColumn: 0, endColumn: 1 }],
+ checkOutOfViewBound: true,
+ hasMergeData: true,
+ });
+ expect(coordinates).toHaveBeenCalled();
expect(ctx.fill).toHaveBeenCalled();
});
it('covers renderBGByCell visibility and merge checks', () => {
- const extension = new Background();
- const rect = vi.fn();
-
- const skeleton = {
- worksheet: {
- getRowVisible: vi.fn(() => true),
- getColVisible: vi.fn(() => true),
- },
- } as any;
-
+ const extension = injector.get(Background);
+ const skeleton = injector.get(SpreadsheetSkeleton).calculate() as SpreadsheetSkeleton;
+ const worksheet = skeleton.worksheet;
+ const backgroundPaths = new Path2D();
+ const rect = vi.spyOn(backgroundPaths, 'rect');
+ const backgroundPositions = skeleton.stylesCache.backgroundPositions;
+ assert.isDefined(backgroundPositions);
const bgContext = {
+ ctx: createCtx(),
spreadsheetSkeleton: skeleton,
- backgroundPaths: { rect },
+ backgroundPositions,
+ checkOutOfViewBound: true,
+ backgroundPaths,
scaleX: 1,
scaleY: 1,
viewRanges: [{ startRow: 10, endRow: 10, startColumn: 10, endColumn: 10 }],
diffRanges: [],
cellInfo: createCellInfo(),
- } as any;
-
- const outOfView = extension.renderBGByCell(bgContext, 0, 0);
- expect(outOfView).toBe(true);
+ skipRenderRangeCheck: false,
+ };
+ expect(extension.renderBGByCell(bgContext, 0, 0)).toBe(true);
expect(rect).not.toHaveBeenCalled();
-
bgContext.viewRanges = [{ startRow: 0, endRow: 0, startColumn: 0, endColumn: 0 }];
- skeleton.worksheet.getRowVisible = vi.fn(() => false);
- const rowHidden = extension.renderBGByCell(bgContext, 0, 0);
- expect(rowHidden).toBe(true);
-
- skeleton.worksheet.getRowVisible = vi.fn(() => true);
+ worksheet.getRowManager().getRowData()[0] = { hd: BooleanNumber.TRUE };
+ expect(extension.renderBGByCell(bgContext, 0, 0)).toBe(true);
+ worksheet.getRowManager().getRowData()[0] = {};
bgContext.viewRanges = [{ startRow: 10, endRow: 10, startColumn: 10, endColumn: 10 }];
bgContext.skipRenderRangeCheck = true;
- const skippedRangeCheck = extension.renderBGByCell(bgContext, 0, 0);
- expect(skippedRangeCheck).toBeUndefined();
+ expect(extension.renderBGByCell(bgContext, 0, 0)).toBeUndefined();
expect(rect).toHaveBeenCalled();
bgContext.skipRenderRangeCheck = false;
-
- bgContext.cellInfo = createCellInfo({
- isMergedMainCell: true,
- mergeInfo: {
- startX: 0,
- startY: 0,
- endX: 10,
- endY: 20,
- startRow: 0,
- endRow: 1,
- startColumn: 0,
- endColumn: 1,
- },
- });
-
- skeleton.worksheet.getRowVisible = vi.fn(() => false);
- const mergedRowHidden = extension.renderBGByCell(bgContext, 0, 0);
- expect(mergedRowHidden).toBe(true);
-
- skeleton.worksheet.getRowVisible = vi.fn(() => true);
- skeleton.worksheet.getColVisible = vi.fn(() => false);
- const mergedColHidden = extension.renderBGByCell(bgContext, 0, 0);
- expect(mergedColHidden).toBe(true);
-
- skeleton.worksheet.getColVisible = vi.fn(() => true);
+ worksheet.getSpanModel().add({ startRow: 0, endRow: 1, startColumn: 0, endColumn: 1 });
+ bgContext.cellInfo = createCellInfo();
+ worksheet.getRowManager().getRowData()[0] = { hd: BooleanNumber.TRUE };
+ worksheet.getRowManager().getRowData()[1] = { hd: BooleanNumber.TRUE };
+ expect(extension.renderBGByCell(bgContext, 0, 0)).toBe(true);
+ worksheet.getRowManager().getRowData()[0] = {};
+ worksheet.getRowManager().getRowData()[1] = {};
+ worksheet.getColumnManager().getColumnData()[0] = { hd: BooleanNumber.TRUE };
+ worksheet.getColumnManager().getColumnData()[1] = { hd: BooleanNumber.TRUE };
+ expect(extension.renderBGByCell(bgContext, 0, 0)).toBe(true);
+ worksheet.getColumnManager().getColumnData()[0] = {};
+ worksheet.getColumnManager().getColumnData()[1] = {};
extension.renderBGByCell(bgContext, 0, 0);
expect(rect).toHaveBeenCalled();
});
diff --git a/packages/engine-render/src/components/sheets/extensions/__tests__/border-row-cache.spec.ts b/packages/engine-render/src/components/sheets/extensions/__tests__/border-row-cache.spec.ts
new file mode 100644
index 0000000000..cfa32dd860
--- /dev/null
+++ b/packages/engine-render/src/components/sheets/extensions/__tests__/border-row-cache.spec.ts
@@ -0,0 +1,223 @@
+/**
+ * Copyright 2023-present DreamNum Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import type { IWorkbookData, Workbook } from '@univerjs/core';
+import { BooleanNumber, BorderStyleTypes, Univer, UniverInstanceType } from '@univerjs/core';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { BORDER_TYPE } from '../../../../basics/const';
+import { UniverRenderingContext } from '../../../../context';
+import { SpreadsheetSkeleton } from '../../sheet.render-skeleton';
+import { BorderRowCache } from '../border-row-cache';
+
+describe('prepared native border row blits', () => {
+ let univer: Univer;
+ let cache: BorderRowCache;
+ let ctx: UniverRenderingContext;
+ let skeleton: SpreadsheetSkeleton;
+ const range = { startRow: 0, endRow: 1, startColumn: 0, endColumn: 9 };
+ const paint = vi.fn<(target: UniverRenderingContext) => void>();
+ let resolved = '#123456';
+ let sprite: HTMLCanvasElement;
+ let paintingRow = 0;
+
+ beforeEach(() => {
+ univer = new Univer();
+ const injector = univer.__getInjector();
+ injector.add([BorderRowCache]);
+ injector.add([UniverRenderingContext, {
+ useFactory: () => injector.createInstance(UniverRenderingContext, document.createElement('canvas').getContext('2d')!),
+ }]);
+ cache = injector.get(BorderRowCache);
+ ctx = injector.get(UniverRenderingContext);
+ ctx.setTransform(1.5, 0, 0, 1.5, 0.5, 0.5);
+ const workbook = univer.createUnit<IWorkbookData, Workbook>(UniverInstanceType.UNIVER_SHEET, {
+ id: 'border-row-cache',
+ sheetOrder: ['sheet'],
+ sheets: {
+ sheet: {
+ id: 'sheet',
+ rowCount: 2,
+ columnCount: 10,
+ defaultRowHeight: 2,
+ defaultColumnWidth: 24,
+ rowHeader: { width: 46, hidden: BooleanNumber.TRUE },
+ columnHeader: { height: 20, hidden: BooleanNumber.TRUE },
+ cellData: Object.fromEntries(Array.from({ length: 2 }, (_, row) => [row, Object.fromEntries(Array.from({ length: 10 }, (_, col) => [col, {
+ s: { bd: {
+ t: { s: BorderStyleTypes.THIN, cl: { rgb: '#123456' } },
+ r: { s: BorderStyleTypes.THIN, cl: { rgb: '#123456' } },
+ } },
+ }]))])),
+ },
+ },
+ });
+ injector.add([SpreadsheetSkeleton, {
+ useFactory: () => injector.createInstance(SpreadsheetSkeleton, workbook.getActiveSheet()!, workbook.getStyles()),
+ }]);
+ skeleton = injector.get(SpreadsheetSkeleton);
+ skeleton.calculate();
+ for (let row = 0; row < 2; row++) {
+ for (let col = 0; col < 10; col++) {
+ const style = skeleton.worksheet.getComposedCellStyle(row, col);
+ skeleton._setBorderStylesCache(row, col, style, undefined);
+ }
+ }
+ resolved = '#123456';
+ paint.mockClear();
+ sprite = document.createElement('canvas');
+ sprite.width = 8;
+ sprite.height = 4;
+ paint.mockImplementation((target) => {
+ const m = target.getTransform();
+ const startY = paintingRow === 0 ? 0 : skeleton.rowHeightAccumulation[paintingRow - 1];
+ const y = Math.floor(Math.round(startY * m.d) + m.f);
+ target.setTransform(1, 0, 0, 1, 0, 0);
+ for (let index = 0; index < 20; index++) {
+ target.drawImage(sprite, Math.floor(m.e) + index * 4, y);
+ }
+ target.setTransform(m.a, m.b, m.c, m.d, m.e, m.f);
+ });
+ });
+
+ afterEach(() => {
+ univer.dispose();
+ vi.restoreAllMocks();
+ });
+
+ const draw = (row = 0) => {
+ paintingRow = row;
+ return cache.draw(ctx, skeleton, row, range, () => resolved, paint);
+ };
+
+ it('keeps the native fallback when no document is available', () => {
+ const descriptor = Object.getOwnPropertyDescriptor(globalThis, 'document')!;
+ Object.defineProperty(globalThis, 'document', { configurable: true, value: undefined });
+ try {
+ expect(draw()).toBe(false);
+ expect(paint).not.toHaveBeenCalled();
+ } finally {
+ Object.defineProperty(globalThis, 'document', descriptor);
+ }
+ });
+
+ it('reuses a row with identical geometry and borders across rows and integral scroll translations', () => {
+ const image = vi.spyOn(ctx._context, 'drawImage');
+ expect(draw()).toBe(true);
+ ctx.translate(0, -2);
+ expect(draw(1)).toBe(true);
+ expect(paint).toHaveBeenCalledTimes(1);
+ expect(image).toHaveBeenCalledTimes(40);
+ expect(image.mock.calls.slice(0, 20)).toEqual(image.mock.calls.slice(20));
+ });
+
+ it('includes edited border contents, resolved theme color, fractional phase and scale in the identity', () => {
+ draw();
+ skeleton.stylesCache.border!.getValue(0, 0)![BORDER_TYPE.TOP] = {
+ type: BORDER_TYPE.TOP,
+ style: BorderStyleTypes.THIN,
+ color: '#abcdef',
+ };
+ draw();
+ resolved = '#654321';
+ draw();
+ ctx.translate(0, 0.2);
+ draw();
+ ctx.scale(2, 2);
+ draw();
+ expect(paint).toHaveBeenCalledTimes(5);
+ });
+
+ it.each(['printing', 'alpha', 'composite', 'rotation', 'shadow', 'tall', 'overflow', 'hidden', 'merged', 'double', 'diagonal', 'transparent'])('retains the original edge renderer for %s', (reason) => {
+ if (reason === 'printing') {
+ ctx.__mode = 'printing';
+ }
+ if (reason === 'alpha') {
+ ctx.globalAlpha = 0.5;
+ }
+ if (reason === 'composite') {
+ ctx.globalCompositeOperation = 'destination-out';
+ }
+ if (reason === 'rotation') {
+ ctx.rotate(0.1);
+ }
+ if (reason === 'shadow') {
+ ctx.shadowBlur = 2;
+ }
+ if (reason === 'tall') {
+ skeleton.rowHeightAccumulation[0] = 40;
+ }
+ if (reason === 'overflow') {
+ skeleton.overflowCache.setValue(0, 0, range);
+ }
+ if (reason === 'hidden') {
+ skeleton.worksheet.getColumnManager().getColumnData()[0] = { hd: BooleanNumber.TRUE };
+ }
+ if (reason === 'merged') {
+ skeleton.worksheet.getSpanModel().add({ startRow: 0, endRow: 1, startColumn: 0, endColumn: 1 });
+ }
+ if (reason === 'double' || reason === 'diagonal') {
+ skeleton.stylesCache.border!.getValue(0, 0)![BORDER_TYPE.TOP] = {
+ type: reason === 'diagonal' ? BORDER_TYPE.TL_BR : BORDER_TYPE.TOP,
+ style: reason === 'double' ? BorderStyleTypes.DOUBLE : BorderStyleTypes.THIN,
+ color: '#123456',
+ };
+ }
+ if (reason === 'transparent') {
+ resolved = 'rgba(0,0,0,0.5)';
+ }
+ expect(draw()).toBe(false);
+ expect(paint).not.toHaveBeenCalled();
+ });
+
+ it('restores the destination transform and smoothing when a cached blit fails', () => {
+ draw();
+ ctx.imageSmoothingEnabled = true;
+ const before = ctx.getTransform();
+ vi.spyOn(ctx._context, 'drawImage').mockImplementationOnce(() => {
+ throw new Error('blit failed');
+ });
+ expect(draw).toThrow('blit failed');
+ expect(ctx.getTransform()).toEqual(before);
+ expect(ctx.imageSmoothingEnabled).toBe(true);
+ });
+
+ it('bounds retained commands and leaves borrowed primitive bitmaps owned by their cache', () => {
+ for (let i = 0; i < 150; i++) {
+ resolved = `#${i.toString(16).padStart(6, '0')}`;
+ draw();
+ }
+ expect((cache as any)._rows.size).toBeLessThan(150);
+ cache.clear();
+ expect((cache as any)._rows.size).toBe(0);
+ expect(sprite.width).toBe(8);
+ });
+
+ it('falls back when a borrowed bitmap is evicted without submitting any stale blits', () => {
+ draw();
+ sprite.width = 0;
+ const image = vi.spyOn(ctx._context, 'drawImage');
+ image.mockClear();
+ expect(draw()).toBe(false);
+ expect(image).not.toHaveBeenCalled();
+ });
+
+ it('does not paint during preparation when a primitive needs the native fallback', () => {
+ paint.mockImplementation((target) => target.stroke());
+ const stroke = vi.spyOn(ctx._context, 'stroke');
+ expect(draw()).toBe(false);
+ expect(stroke).not.toHaveBeenCalled();
+ });
+});
diff --git a/packages/engine-render/src/components/sheets/extensions/__tests__/border.spec.ts b/packages/engine-render/src/components/sheets/extensions/__tests__/border.spec.ts
index 26a05b108a..20ee04b842 100644
--- a/packages/engine-render/src/components/sheets/extensions/__tests__/border.spec.ts
+++ b/packages/engine-render/src/components/sheets/extensions/__tests__/border.spec.ts
@@ -14,36 +14,29 @@
* limitations under the License.
*/
-import { BorderStyleTypes, ObjectMatrix } from '@univerjs/core';
-import { beforeEach, describe, expect, it, vi } from 'vitest';
+import type { Injector, IWorkbookData, Workbook } from '@univerjs/core';
+import { BooleanNumber, BorderStyleTypes, ObjectMatrix, Univer, UniverInstanceType } from '@univerjs/core';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
import { BORDER_TYPE } from '../../../../basics/const';
+import { UniverRenderingContext } from '../../../../context';
+import { SpreadsheetSkeleton } from '../../sheet.render-skeleton';
import { Border } from '../border';
-const drawDiagonalLineByBorderTypeMock = vi.fn((..._args: any[]) => undefined);
-const drawLineByBorderTypeMock = vi.fn((..._args: any[]) => undefined);
-const getLineWidthMock = vi.fn((..._args: any[]) => 1);
-const setLineTypeMock = vi.fn((..._args: any[]) => undefined);
-
-vi.mock('../../../../basics/draw', () => ({
- drawDiagonalLineByBorderType: (...args: any[]) => drawDiagonalLineByBorderTypeMock(...args),
- drawLineByBorderType: (...args: any[]) => drawLineByBorderTypeMock(...args),
- getLineWidth: (...args: any[]) => getLineWidthMock(...args),
- setLineType: (...args: any[]) => setLineTypeMock(...args),
-}));
+let injector: Injector;
+let univer: Univer;
function createCtx() {
- return {
- save: vi.fn(),
- restore: vi.fn(),
- beginPath: vi.fn(),
- closePath: vi.fn(),
- translateWithPrecisionRatio: vi.fn(),
- setLineWidthByPrecision: vi.fn(),
- getScale: vi.fn(() => ({ scaleX: 1, scaleY: 1 })),
- strokeStyle: '',
- lineCap: 'round',
- globalCompositeOperation: 'source-over',
- } as any;
+ const native = document.createElement('canvas').getContext('2d')!;
+ const ctx = injector.createChild([[UniverRenderingContext, {
+ useFactory: function createTestInstance() {
+ return injector.createInstance(UniverRenderingContext, native);
+ },
+ }]]).get(UniverRenderingContext);
+ for (const method of ['save', 'restore', 'beginPath', 'closePath', 'translateWithPrecisionRatio', 'setLineWidthByPrecision', 'setLineDash', 'stroke', 'moveToByPrecision', 'lineToByPrecision'] as const) {
+ vi.spyOn(ctx, method);
+ }
+ ctx.lineCap = 'round';
+ return ctx;
}
function createCellInfo(overrides?: Partial<any>) {
@@ -70,11 +63,76 @@ function createCellInfo(overrides?: Partial<any>) {
describe('border extension', () => {
beforeEach(() => {
+ univer = new Univer();
+ injector = univer.__getInjector();
+ const workbook = univer.createUnit<IWorkbookData, Workbook>(UniverInstanceType.UNIVER_SHEET, {
+ id: 'border-render',
+ sheetOrder: ['sheet'],
+ sheets: { sheet: {
+ id: 'sheet',
+ rowCount: 10,
+ columnCount: 10,
+ defaultRowHeight: 10,
+ defaultColumnWidth: 20,
+ rowHeader: { width: 46, hidden: BooleanNumber.TRUE },
+ columnHeader: { height: 20, hidden: BooleanNumber.TRUE },
+ cellData: { 0: { 0: { s: { bd: { t: { s: BorderStyleTypes.THIN, cl: { rgb: '#111111' } } } } } } },
+ } },
+ });
+ injector.add([Border]);
+ injector.add([SpreadsheetSkeleton, {
+ useFactory: function createSkeleton() {
+ return injector.createInstance(SpreadsheetSkeleton, workbook.getActiveSheet()!, workbook.getStyles());
+ },
+ }]);
vi.clearAllMocks();
});
+ afterEach(() => univer.dispose());
+
+ it('reuses a consecutive brush without omitting edges and reapplies dash transitions', () => {
+ const extension = injector.get(Border);
+ const ctx = createCtx();
+ const skeleton = injector.get(SpreadsheetSkeleton).calculate() as SpreadsheetSkeleton;
+ const context: Parameters<Border['renderBorderByCell']>[0] = {
+ ctx,
+ precisionScale: 1,
+ overflowCache: skeleton.overflowCache,
+ spreadsheetSkeleton: skeleton,
+ diffRanges: [],
+ viewRanges: [],
+ };
+ const solid = Object.fromEntries([BORDER_TYPE.TOP, BORDER_TYPE.RIGHT, BORDER_TYPE.BOTTOM, BORDER_TYPE.LEFT]
+ .map((type) => [type, { type, style: BorderStyleTypes.THIN, color: '#111' }]));
+ for (let col = 0; col < 4; col++) {
+ extension.renderBorderByCell(context, 0, col, solid);
+ }
+ expect(ctx.stroke).toHaveBeenCalledTimes(16);
+ expect(ctx.setLineDash).toHaveBeenCalledExactlyOnceWith([]);
+ expect(ctx.setLineWidthByPrecision).toHaveBeenCalledTimes(1);
+ extension.renderBorderByCell(context, 0, 4, {
+ [BORDER_TYPE.TOP]: { type: BORDER_TYPE.TOP, style: BorderStyleTypes.DASHED, color: '#222' },
+ [BORDER_TYPE.BOTTOM]: { type: BORDER_TYPE.BOTTOM, style: BorderStyleTypes.THIN, color: '#111' },
+ });
+ expect(vi.mocked(ctx.setLineDash).mock.calls.map(([dash]) => dash)).toEqual([[], [3], []]);
+ expect(ctx.stroke).toHaveBeenCalledTimes(18);
+ expect(ctx.strokeStyle).toBe('#111111');
+ });
+
+ it('checks only the border row for overflow exclusions', () => {
+ const extension = injector.get(Border) as any;
+ const overflow = new ObjectMatrix({
+ 3: { 1: { startRow: 3, endRow: 3, startColumn: 1, endColumn: 4 } },
+ 999: new Proxy({}, { ownKeys: () => { throw new Error('Unrelated overflow row enumerated'); } }),
+ });
+ expect(extension._getOverflowExclusion(overflow, BORDER_TYPE.LEFT, 3, 2)).toBe(true);
+ expect(extension._getOverflowExclusion(overflow, BORDER_TYPE.RIGHT, 3, 4)).toBe(false);
+ expect(extension._getOverflowExclusion(overflow, BORDER_TYPE.LEFT, 5, 2)).toBe(false);
+ expect(extension._getOverflowExclusion(overflow, BORDER_TYPE.TOP, 3, 2)).toBe(false);
+ });
+
it('returns early on invalid draw preconditions and iterates valid range', () => {
- const extension = new Border();
+ const extension = injector.get(Border);
const ctx = createCtx();
extension.draw(ctx, { scaleX: 1, scaleY: 1 } as any, { stylesCache: {} } as any, [], { viewRanges: [] } as any);
@@ -109,8 +167,36 @@ describe('border extension', () => {
expect(ctx.translateWithPrecisionRatio).toHaveBeenCalled();
});
+ it('keeps live native transforms for custom border renderers', () => {
+ const scales: { scaleX: number; scaleY: number }[] = [];
+ class CustomBorder extends Border {
+ override renderBorderByCell({ ctx }: Parameters<Border['renderBorderByCell']>[0]) {
+ ctx.getScale();
+ ctx._context.scale(2, 3);
+ scales.push(ctx.getScale());
+ return undefined;
+ }
+ }
+ const extension = injector.createChild([[CustomBorder, { useFactory: function createTestInstance() {
+ return injector.createInstance(CustomBorder);
+ } }]]).get(CustomBorder);
+ const native = document.createElement('canvas').getContext('2d')!;
+ native.scale(1.25, 1.5);
+ const ctx = injector.createChild([[UniverRenderingContext, { useFactory: function createTestInstance() {
+ return injector.createInstance(UniverRenderingContext, native);
+ } }]]).get(UniverRenderingContext);
+ const skeleton = injector.get(SpreadsheetSkeleton).calculate() as SpreadsheetSkeleton;
+ skeleton._setBorderStylesCache(0, 0, skeleton.worksheet.getComposedCellStyle(0, 0), undefined);
+ extension.draw(ctx, { scaleX: 1.25, scaleY: 1.5 }, skeleton, [], {
+ viewportKey: 'viewMain',
+ viewRanges: [{ startRow: 0, endRow: 0, startColumn: 0, endColumn: 0 }],
+ });
+ expect(scales).toEqual([{ scaleX: 2.5, scaleY: 4.5 }]);
+ expect(ctx.getScale()).toEqual({ scaleX: 1.25, scaleY: 1.5 });
+ });
+
it('handles renderBorderByCell hidden/diff branches', () => {
- const extension = new Border();
+ const extension = injector.get(Border);
const ctx = createCtx();
const overflowCache = new ObjectMatrix<any>();
@@ -146,7 +232,7 @@ describe('border extension', () => {
});
it.each([BORDER_TYPE.TL_BR, BORDER_TYPE.BL_TR])('keeps outer borders after skipping a merged child diagonal %s', (diagonalType) => {
- const extension = new Border();
+ const extension = injector.get(Border);
const ctx = createCtx();
const renderBorderContext = {
ctx,
@@ -173,12 +259,13 @@ describe('border extension', () => {
[BORDER_TYPE.BOTTOM]: { type: BORDER_TYPE.BOTTOM, style: BorderStyleTypes.THIN, color: '#000000' },
});
- expect(drawLineByBorderTypeMock.mock.calls.map((call) => call[1])).toEqual([BORDER_TYPE.LEFT, BORDER_TYPE.BOTTOM]);
- expect(drawDiagonalLineByBorderTypeMock.mock.calls.map((call) => call[2])).not.toContain(diagonalType);
+ expect(ctx.stroke).toHaveBeenCalledTimes(2);
+ expect(vi.mocked(ctx.moveToByPrecision).mock.calls).toEqual([[0, -0.5], [0, 10]]);
+ expect(vi.mocked(ctx.lineToByPrecision).mock.calls).toEqual([[0, 10.5], [20, 10]]);
});
it('renders regular/diagonal/double borders and internal helpers', () => {
- const extension = new Border() as any;
+ const extension = injector.get(Border) as any;
const ctx = createCtx();
const overflowCache = new ObjectMatrix<any>();
const borderMatrix = new ObjectMatrix<any>();
@@ -207,13 +294,14 @@ describe('border extension', () => {
viewRanges: [],
} as any;
- const doubleSpy = vi.spyOn(extension, '_renderDoubleBorder').mockImplementation(() => {});
+ const doubleSpy = vi.spyOn(extension, '_renderDoubleBorder');
extension.renderBorderByCell(renderBorderContext, 0, 0, borderConfig);
- expect(getLineWidthMock).toHaveBeenCalled();
- expect(setLineTypeMock).toHaveBeenCalled();
- expect(drawDiagonalLineByBorderTypeMock).toHaveBeenCalled();
- expect(drawLineByBorderTypeMock).toHaveBeenCalled();
+ expect(ctx.setLineWidthByPrecision).toHaveBeenCalledWith(1);
+ expect(ctx.setLineDash).toHaveBeenCalledWith([]);
+ expect(ctx.lineToByPrecision).toHaveBeenCalledWith(20, 10);
+ expect(ctx.lineToByPrecision).toHaveBeenCalledWith(20, 0);
+ expect(ctx.lineToByPrecision).toHaveBeenCalledWith(0, 10);
expect(doubleSpy).toHaveBeenCalled();
overflowCache.setValue(1, 3, {
@@ -238,7 +326,7 @@ describe('border extension', () => {
});
it('covers detailed double-border offset branches for vertical and horizontal lines', () => {
- const extension = new Border() as any;
+ const extension = injector.get(Border) as any;
const ctx = createCtx();
const borderCache = new ObjectMatrix<any>();
@@ -313,7 +401,7 @@ describe('border extension', () => {
endY: 0,
});
- expect(drawLineByBorderTypeMock).toHaveBeenCalled();
+ expect(ctx.stroke).toHaveBeenCalled();
expect(ctx.save).toHaveBeenCalled();
expect(ctx.restore).toHaveBeenCalled();
});
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 5274894be1..ad279273aa 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
@@ -15,15 +15,18 @@
*/
import type { IWorkbookData, Workbook } from '@univerjs/core';
-import { BooleanNumber, CellValueType, HorizontalAlign, LocaleType, ObjectMatrix, Univer, UniverInstanceType, VerticalAlign, WrapStrategy } from '@univerjs/core';
-import { beforeEach, describe, expect, it, vi } from 'vitest';
+import { BooleanNumber, CellValueType, HorizontalAlign, Injector, LocaleType, ObjectMatrix, Univer, UniverInstanceType, VerticalAlign, WrapStrategy } from '@univerjs/core';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
import { setupRenderTestEnv } from '../../../../__tests__/render-test-utils';
import { VERTICAL_ROTATE_ANGLE } from '../../../../basics/text-rotation';
import { UniverRenderingContext2D } from '../../../../context';
+import { Rect } from '../../../../shape/rect';
import { Text } from '../../../../shape/text';
import { SpreadsheetSkeleton } from '../../sheet.render-skeleton';
import { Font } from '../font';
+let injector: Injector;
+
function createCtx() {
return {
save: vi.fn(),
@@ -118,6 +121,7 @@ function createSpreadsheetSkeleton() {
describe('font extension', () => {
beforeEach(() => {
+ injector = new Injector([[Font]]);
vi.restoreAllMocks();
vi.stubGlobal('Image', class {
complete = true;
@@ -126,6 +130,34 @@ describe('font extension', () => {
});
});
+ afterEach(() => injector.dispose());
+
+ it.each([false, true])('invalidates loaded fallback image pixels and disconnects after disposal (loaded: %s)', (loaded) => {
+ const image = document.createElement('img');
+ vi.stubGlobal('Image', vi.fn(function () {
+ return image;
+ }));
+ const extension = injector.get(Font);
+ const parent = injector.createChild([[Rect, { useFactory: function createTestInstance() {
+ return injector.createInstance(Rect, 'fallback-image-parent', {});
+ } }]]).get(Rect);
+ const dirty = vi.spyOn(parent, 'makeDirty');
+ extension.parent = parent;
+ try {
+ if (loaded) {
+ image.dispatchEvent(new Event('load'));
+ expect(dirty).toHaveBeenCalledExactlyOnceWith(true);
+ }
+ extension.dispose();
+ expect(image.onload).toBeNull();
+ image.dispatchEvent(new Event('load'));
+ expect(dirty).toHaveBeenCalledTimes(Number(loaded));
+ } finally {
+ extension.dispose();
+ parent.dispose();
+ }
+ });
+
it.each([
['hidden columns', false, false, true],
['hidden rows', true, false, true],
@@ -171,7 +203,13 @@ describe('font extension', () => {
},
});
const worksheet = workbook.getActiveSheet()!;
- const skeleton = univer.__getInjector().createInstance(SpreadsheetSkeleton, worksheet, workbook.getStyles());
+ const testInjector = univer.__getInjector();
+ testInjector.add([SpreadsheetSkeleton, {
+ useFactory: function createSkeleton() {
+ return testInjector.createInstance(SpreadsheetSkeleton, worksheet, workbook.getStyles());
+ },
+ }]);
+ const skeleton = testInjector.get(SpreadsheetSkeleton);
const context = document.createElement('canvas').getContext('2d')!;
const fillText = vi.spyOn(context, 'fillText');
try {
@@ -186,7 +224,9 @@ describe('font extension', () => {
const cell = worksheet.getCellRaw(index, index)!;
skeleton._setFontStylesCache(index, index, cell, worksheet.getComposedCellStyleByCellData(index, index, cell));
}
- new Font().draw(new UniverRenderingContext2D(context), { scaleX: 1, scaleY: 1 }, skeleton, [], {
+ injector.get(Font).draw(injector.createChild([[UniverRenderingContext2D, { useFactory: function createTestInstance() {
+ return injector.createInstance(UniverRenderingContext2D, context);
+ } }]]).get(UniverRenderingContext2D), { scaleX: 1, scaleY: 1 }, skeleton, [], {
viewRanges: [{ startRow: 0, endRow: 4, startColumn: 0, endColumn: 4 }],
viewportKey: 'viewMain',
});
@@ -200,7 +240,7 @@ describe('font extension', () => {
});
it('covers fallback image draw branches', () => {
- const font = new Font() as any;
+ const font = injector.get(Font) as any;
const ctx = createCtx();
const errorSpy = vi.spyOn(console, 'error').mockImplementation(() => undefined);
@@ -219,7 +259,7 @@ describe('font extension', () => {
});
it('covers clip bounds for overflow/offset align branches', () => {
- const font = new Font() as any;
+ const font = injector.get(Font) as any;
const ctx = createCtx();
const clipOverflowSpy = vi.spyOn(font, '_clipRectangleForOverflow').mockImplementation(() => undefined);
const skeleton = createSpreadsheetSkeleton();
@@ -293,7 +333,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 font = injector.get(Font) as any;
const ctx = createCtx();
const renderFontCtx = {
@@ -363,7 +403,7 @@ describe('font extension', () => {
});
it('covers documents render branches and missing documents error', () => {
- const font = new Font() as any;
+ const font = injector.get(Font) as any;
const ctx = createCtx();
const overflow = new ObjectMatrix<any>();
const spreadsheetSkeleton = createSpreadsheetSkeleton();
@@ -439,7 +479,7 @@ describe('font extension', () => {
});
it('uses the natural content width for a non-wrapped document without cell overflow', () => {
- const font = new Font() as any;
+ const font = injector.get(Font) as any;
const ctx = createCtx();
const overflow = new ObjectMatrix<any>();
const spreadsheetSkeleton = createSpreadsheetSkeleton();
@@ -544,7 +584,7 @@ describe('font extension', () => {
it.each([HorizontalAlign.JUSTIFIED, HorizontalAlign.DISTRIBUTED])(
'keeps the cell width while rendering full-width alignment %s',
(horizontalAlign) => {
- const font = new Font() as any;
+ const font = injector.get(Font) as any;
const ctx = createCtx();
const overflow = new ObjectMatrix<any>();
const spreadsheetSkeleton = createSpreadsheetSkeleton();
@@ -590,7 +630,7 @@ describe('font extension', () => {
);
it('covers image rendering fallback branches', () => {
- const font = new Font() as any;
+ const font = injector.get(Font) as any;
const ctx = createCtx();
const fallbackSpy = vi.spyOn(font, '_drawFallbackImage').mockImplementation(() => undefined);
@@ -643,7 +683,7 @@ describe('font extension', () => {
});
it('renders cell images from cell alignment, independent of document layout offsets', () => {
- const font = new Font() as any;
+ const font = injector.get(Font) as any;
const image = { complete: true, getAttribute: vi.fn(() => 'false') };
const createImageFontCache = (aLeft: number, wrapStrategy: WrapStrategy) => createFontCache({
@@ -691,7 +731,7 @@ describe('font extension', () => {
});
it('renders cell images inside the cell padding box', () => {
- const font = new Font() as any;
+ const font = injector.get(Font) as any;
const ctx = createCtx();
const image = { complete: true, getAttribute: vi.fn(() => 'false') };
const fontCache = createFontCache({
@@ -734,7 +774,7 @@ describe('font extension', () => {
});
it('covers draw and render-each-cell early/normal branches', () => {
- const font = new Font() as any;
+ const font = injector.get(Font) as any;
const ctx = createCtx();
const spreadsheetSkeleton = createSpreadsheetSkeleton();
const fontMatrix = new ObjectMatrix<any>();
@@ -857,7 +897,7 @@ describe('font extension', () => {
});
it('does not read live cell data for plain cached font cells', () => {
- const font = new Font() as any;
+ const font = injector.get(Font) as any;
const ctx = createCtx();
const spreadsheetSkeleton = createSpreadsheetSkeleton();
const fontMatrix = new ObjectMatrix<any>();
@@ -884,7 +924,7 @@ describe('font extension', () => {
});
it('draws fitting plain text without clipping', () => {
- const font = new Font() as any;
+ const font = injector.get(Font) as any;
const ctx = createCtx();
const spreadsheetSkeleton = createSpreadsheetSkeleton();
const fontMatrix = new ObjectMatrix<any>();
@@ -925,7 +965,7 @@ describe('font extension', () => {
});
it('checks live cell data for cached font render extensions', () => {
- const font = new Font() as any;
+ const font = injector.get(Font) as any;
const ctx = createCtx();
const spreadsheetSkeleton = createSpreadsheetSkeleton();
const fontMatrix = new ObjectMatrix<any>();
@@ -956,7 +996,7 @@ describe('font extension', () => {
});
it('skips coordinate calculation for cells without font cache', () => {
- const font = new Font() as any;
+ const font = injector.get(Font) as any;
const ctx = createCtx();
const spreadsheetSkeleton = createSpreadsheetSkeleton();
const fontMatrix = new ObjectMatrix<any>();
@@ -977,8 +1017,77 @@ describe('font extension', () => {
expect(renderCellSpy).toHaveBeenCalledOnce();
});
+ it.each([undefined, 0, 19])('preserves native overflow glyph output for damage clip %s', (clipTop) => {
+ const environment = setupRenderTestEnv();
+ const univer = new Univer({ locale: LocaleType.EN_US });
+ const testInjector = univer.__getInjector();
+ const workbook = univer.createUnit<IWorkbookData, Workbook>(UniverInstanceType.UNIVER_SHEET, {
+ id: 'native-overflow-text',
+ sheetOrder: ['sheet'],
+ sheets: {
+ sheet: {
+ id: 'sheet',
+ rowCount: 3,
+ columnCount: 3,
+ defaultRowHeight: 20,
+ defaultColumnWidth: 40,
+ rowHeader: { width: 46, hidden: BooleanNumber.TRUE },
+ columnHeader: { height: 20, hidden: BooleanNumber.TRUE },
+ cellData: { 0: { 0: { v: 'overflow text beyond the cell'.repeat(4), s: { tb: WrapStrategy.OVERFLOW } } } },
+ },
+ },
+ });
+ testInjector.add([Font]);
+ testInjector.add([SpreadsheetSkeleton, {
+ useFactory: function createSkeleton() {
+ return testInjector.createInstance(SpreadsheetSkeleton, workbook.getActiveSheet()!, workbook.getStyles());
+ },
+ }]);
+ testInjector.add([UniverRenderingContext2D, {
+ useFactory: function createContext() {
+ return testInjector.createInstance(UniverRenderingContext2D, document.createElement('canvas').getContext('2d')!);
+ },
+ }]);
+ const font = testInjector.get(Font);
+ const ctx = testInjector.get(UniverRenderingContext2D);
+ const skeleton = testInjector.get(SpreadsheetSkeleton);
+ const range = { startRow: 0, endRow: 0, startColumn: 0, endColumn: 0 };
+ const clip = clipTop === undefined ? undefined : { left: 0, top: clipTop, right: 120, bottom: 60 };
+ const text = [vi.spyOn(ctx._context, 'fillText')];
+ const getContext = vi.isMockFunction(HTMLCanvasElement.prototype.getContext)
+ ? vi.mocked(HTMLCanvasElement.prototype.getContext).getMockImplementation()!
+ : HTMLCanvasElement.prototype.getContext;
+ vi.spyOn(HTMLCanvasElement.prototype, 'getContext').mockImplementation(function (this: HTMLCanvasElement, ...args) {
+ const native = Reflect.apply(getContext, this, args);
+ if (native && 'fillText' in native) {
+ text.push(vi.spyOn(native, 'fillText'));
+ }
+ return native;
+ });
+ try {
+ skeleton.calculate();
+ const worksheet = workbook.getActiveSheet()!;
+ const cell = worksheet.getCellRaw(0, 0)!;
+ skeleton._setFontStylesCache(0, 0, cell, worksheet.getComposedCellStyle(0, 0));
+ expect(skeleton.stylesCache.fontMatrix.getValue(0, 0)?.textFitsCurrentCell).toBe(false);
+ font.draw(ctx, { scaleX: 1, scaleY: 1 }, skeleton, [range], {
+ viewRanges: [range],
+ viewportKey: 'viewMain',
+ textClipBound: clip,
+ });
+ expect(text.flatMap((paint) => paint.mock.calls)).toContainEqual([
+ 'overflow text beyond the cell'.repeat(4),
+ expect.any(Number),
+ expect.any(Number),
+ ]);
+ } finally {
+ univer.dispose();
+ environment.restore();
+ }
+ });
+
it('skips font work for rows that are too short to display text on screen', () => {
- const font = new Font() as any;
+ const font = injector.get(Font) as any;
const ctx = createCtx();
const spreadsheetSkeleton = createSpreadsheetSkeleton();
const fontMatrix = new ObjectMatrix<any>();
@@ -1016,7 +1125,7 @@ describe('font extension', () => {
});
it('skips merge lookup work when the sheet has no merged cells', () => {
- const font = new Font() as any;
+ const font = injector.get(Font) as any;
const ctx = createCtx();
const spreadsheetSkeleton = createSpreadsheetSkeleton();
const fontMatrix = new ObjectMatrix<any>();
@@ -1040,7 +1149,7 @@ describe('font extension', () => {
});
it('does not mutate shared view ranges when expanding text overflow bounds', () => {
- const font = new Font() as any;
+ const font = injector.get(Font) as any;
const ctx = createCtx();
const spreadsheetSkeleton = createSpreadsheetSkeleton();
const fontMatrix = new ObjectMatrix<any>();
diff --git a/packages/engine-render/src/components/sheets/extensions/__tests__/render-primitive-cache.spec.ts b/packages/engine-render/src/components/sheets/extensions/__tests__/render-primitive-cache.spec.ts
new file mode 100644
index 0000000000..382e8d071d
--- /dev/null
+++ b/packages/engine-render/src/components/sheets/extensions/__tests__/render-primitive-cache.spec.ts
@@ -0,0 +1,549 @@
+/**
+ * Copyright 2023-present DreamNum Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import { Injector } from '@univerjs/core';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { UniverRenderingContext } from '../../../../context';
+import { FontCache } from '../../../docs/layout/shaping-engine/font-cache';
+import { Border } from '../border';
+import { RenderPrimitiveCache } from '../render-primitive-cache';
+
+describe('render primitive raster cache', () => {
+ let injector: Injector;
+ let cache: RenderPrimitiveCache;
+ let native: CanvasRenderingContext2D;
+ let ctx: UniverRenderingContext;
+ let fonts: EventTarget & { status: string };
+ let fontsDescriptor: PropertyDescriptor | undefined;
+
+ beforeEach(() => {
+ native = document.createElement('canvas').getContext('2d')!;
+ injector = new Injector([
+ [RenderPrimitiveCache],
+ [Border],
+ [EventTarget],
+ [CanvasRenderingContext2D, { useValue: native }],
+ [UniverRenderingContext, {
+ useFactory: (container: Injector, context: CanvasRenderingContext2D) =>
+ container.createInstance(UniverRenderingContext, context),
+ deps: [Injector, CanvasRenderingContext2D],
+ }],
+ ]);
+ cache = injector.get(RenderPrimitiveCache);
+ ctx = injector.get(UniverRenderingContext);
+ ctx.strokeStyle = '#1d4ed8';
+ native.canvas.dir = 'ltr';
+ fonts = Object.assign(injector.get(EventTarget), { status: 'loaded' });
+ fontsDescriptor = Object.getOwnPropertyDescriptor(document, 'fonts');
+ Object.defineProperty(document, 'fonts', { configurable: true, value: fonts });
+ });
+
+ afterEach(() => {
+ cache.dispose();
+ injector.dispose();
+ vi.restoreAllMocks();
+ if (fontsDescriptor) {
+ Object.defineProperty(document, 'fonts', fontsDescriptor);
+ } else {
+ Reflect.deleteProperty(document, 'fonts');
+ }
+ });
+
+ function line(): void {
+ cache.draw(ctx, () => {
+ ctx.beginPath();
+ ctx.moveToByPrecision(10, 20);
+ ctx.lineToByPrecision(64, 45);
+ ctx.stroke();
+ });
+ }
+
+ it('reuses identical physical strokes after integral translations and restores the native context', () => {
+ const stroke = vi.spyOn(native, 'stroke');
+ const image = vi.spyOn(native, 'drawImage');
+ line();
+ ctx.setTransform(1, 0, 0, 1, -162, 100);
+ line();
+
+ expect(stroke).not.toHaveBeenCalled();
+ expect(image).toHaveBeenCalledTimes(2);
+ expect(image.mock.calls[1][0]).toBe(image.mock.calls[0][0]);
+ expect(ctx._context).toBe(native);
+ expect(native.getTransform().e).toBe(-162);
+ });
+
+ it.each(['horizontal', 'vertical', 'reverse', 'fractional-width', 'dash', 'round-cap', 'round-join', 'zero'])('retains native stroke semantics for %s lines', (mode) => {
+ const image = vi.spyOn(native, 'drawImage');
+ if (mode === 'fractional-width') ctx.lineWidth = 2;
+ if (mode === 'dash') ctx.setLineDash([2, 2]);
+ if (mode === 'round-cap') ctx.lineCap = 'round';
+ if (mode === 'round-join') ctx.lineJoin = 'round';
+ cache.draw(ctx, () => {
+ ctx.beginPath();
+ ctx.moveTo(10.5, 20.5);
+ ctx.lineTo(mode === 'vertical' || mode === 'zero' ? 10.5 : mode === 'reverse' ? 2.5 : 64.5, mode === 'vertical' ? 64.5 : 20.5);
+ ctx.closePath();
+ ctx.stroke();
+ });
+ const paint = (image.mock.calls[0][0] as HTMLCanvasElement).getContext('2d')!;
+ const usesRectangle = ['horizontal', 'vertical', 'reverse'].includes(mode);
+ expect(paint.fillRect).toHaveBeenCalledTimes(usesRectangle ? 1 : 0);
+ expect(paint.stroke).toHaveBeenCalledTimes(usesRectangle ? 0 : 1);
+ expect(native.strokeStyle).toBe('#1d4ed8');
+ expect(native.getTransform()).toMatchObject({ a: 1, d: 1, e: 0, f: 0 });
+ });
+
+ it.each([20, 21, 30])('repairs only antialiased text edges culled by the damage clip at %s', (top) => {
+ const text = vi.spyOn(native, 'fillText');
+ const image = vi.spyOn(native, 'drawImage');
+ vi.spyOn(native, 'measureText').mockReturnValue({
+ actualBoundingBoxLeft: 0,
+ actualBoundingBoxRight: 10,
+ actualBoundingBoxAscent: 10,
+ actualBoundingBoxDescent: 0.2,
+ } as TextMetrics);
+ cache.draw(ctx, () => ctx.fillText('tail', 2.5, 20.5), { left: 0, top, right: 100, bottom: 40 });
+
+ expect(image).toHaveBeenCalledTimes(top === 21 ? 1 : 0);
+ expect(text).toHaveBeenCalledTimes(top === 21 ? 0 : 1);
+ });
+
+ it.each(['left', 'right', 'top', 'bottom'])('repairs a culled %s text edge in transformed physical pixels', (edge) => {
+ ctx.setTransform(2, 0, 0, 2, 10, 14);
+ const text = vi.spyOn(native, 'fillText');
+ const image = vi.spyOn(native, 'drawImage');
+ vi.spyOn(native, 'measureText').mockReturnValue({
+ actualBoundingBoxLeft: 0,
+ actualBoundingBoxRight: 10,
+ actualBoundingBoxAscent: 10,
+ actualBoundingBoxDescent: 0.2,
+ } as TextMetrics);
+ const clip = { left: 0, top: 0, right: 100, bottom: 100 };
+ if (edge === 'left') clip.left = 36;
+ if (edge === 'right') clip.right = 14;
+ if (edge === 'top') clip.top = 56;
+ if (edge === 'bottom') clip.bottom = 34;
+ cache.draw(ctx, () => ctx.fillText('tail', 2.5, 20.5), clip);
+
+ expect(image).toHaveBeenCalledOnce();
+ expect(text).not.toHaveBeenCalled();
+ expect(native.getTransform()).toMatchObject({ a: 2, d: 2, e: 10, f: 14 });
+ });
+
+ it('preserves native glyph coordinates at a clipped antialiasing edge', () => {
+ native.canvas.width = 600;
+ native.canvas.height = 400;
+ ctx.setTransform(2, 0, 0, 2, 10, 14);
+ const image = vi.spyOn(native, 'drawImage');
+ vi.spyOn(native, 'measureText').mockReturnValue({
+ actualBoundingBoxLeft: 0,
+ actualBoundingBoxRight: 10,
+ actualBoundingBoxAscent: 10,
+ actualBoundingBoxDescent: 0.2,
+ } as TextMetrics);
+ cache.draw(ctx, () => ctx.fillText('tail', 2.5, 20.5), { left: 0, top: 56, right: 100, bottom: 100 });
+
+ const surface = image.mock.calls[0][0] as HTMLCanvasElement;
+ const paint = surface.getContext('2d')!;
+ expect([surface.width, surface.height]).toEqual([600, 400]);
+ expect(paint.fillText).toHaveBeenCalledWith('tail', 2.5, 20.5);
+ expect(paint.getTransform()).toMatchObject({ a: 2, d: 2, e: 10, f: 14 });
+ expect(native.getTransform()).toMatchObject({ a: 2, d: 2, e: 10, f: 14 });
+ });
+
+ it('reuses one clipped-text repair surface and releases it when the cache is cleared', () => {
+ const image = vi.spyOn(native, 'drawImage');
+ vi.spyOn(native, 'measureText').mockReturnValue({
+ actualBoundingBoxLeft: 0,
+ actualBoundingBoxRight: 10,
+ actualBoundingBoxAscent: 10,
+ actualBoundingBoxDescent: 0.2,
+ } as TextMetrics);
+ const repair = () => cache.draw(ctx, () => ctx.fillText('tail', 2.5, 20.5), {
+ left: 0,
+ top: 21,
+ right: 100,
+ bottom: 40,
+ });
+ repair();
+ ctx.fillStyle = '#be123c';
+ repair();
+ const first = image.mock.calls[0][0] as HTMLCanvasElement;
+ expect(image.mock.calls[1][0]).toBe(first);
+ cache.clear();
+ expect([first.width, first.height]).toEqual([0, 0]);
+ repair();
+ const afterClear = image.mock.calls[2][0] as HTMLCanvasElement;
+ expect(afterClear).not.toBe(first);
+ cache.dispose();
+ expect([afterClear.width, afterClear.height]).toEqual([0, 0]);
+ });
+
+ it('resizes the clipped-text surface with its native viewport', () => {
+ const image = vi.spyOn(native, 'drawImage');
+ vi.spyOn(native, 'measureText').mockReturnValue({
+ actualBoundingBoxLeft: 0,
+ actualBoundingBoxRight: 10,
+ actualBoundingBoxAscent: 10,
+ actualBoundingBoxDescent: 0.2,
+ } as TextMetrics);
+ for (const [width, height] of [[600, 400], [200, 100]]) {
+ native.canvas.width = width;
+ native.canvas.height = height;
+ cache.draw(ctx, () => ctx.fillText('tail', 2.5, 20.5), {
+ left: 0,
+ top: 21,
+ right: 100,
+ bottom: 40,
+ });
+ const surface = image.mock.calls[image.mock.calls.length - 1][0] as HTMLCanvasElement;
+ expect([surface.width, surface.height]).toEqual([width, height]);
+ expect(surface).toBe(image.mock.calls[0][0]);
+ }
+ });
+
+ it('restores native state if clipped-text repair submission fails', () => {
+ native.save();
+ ctx.setTransform(2, 0, 0, 2, 10, 14);
+ ctx.globalAlpha = 0.6;
+ ctx.imageSmoothingEnabled = true;
+ vi.spyOn(native, 'measureText').mockReturnValue({
+ actualBoundingBoxLeft: 0,
+ actualBoundingBoxRight: 10,
+ actualBoundingBoxAscent: 10,
+ actualBoundingBoxDescent: 0.2,
+ } as TextMetrics);
+ vi.spyOn(native, 'drawImage').mockImplementation(() => {
+ throw new Error('Clipped text submission failed');
+ });
+ expect(() => cache.draw(ctx, () => ctx.fillText('tail', 2.5, 20.5), {
+ left: 0,
+ top: 56,
+ right: 100,
+ bottom: 100,
+ })).toThrow('Clipped text submission failed');
+ expect(ctx._context).toBe(native);
+ expect(native.getTransform()).toMatchObject({ a: 2, d: 2, e: 10, f: 14 });
+ expect(native.globalAlpha).toBe(0.6);
+ expect(native.imageSmoothingEnabled).toBe(true);
+ native.restore();
+ expect(native.getTransform()).toMatchObject({ a: 1, d: 1, e: 0, f: 0 });
+ });
+
+ it('keeps text decorations native and releases the damage bound after exceptions', () => {
+ const stroke = vi.spyOn(native, 'stroke');
+ const image = vi.spyOn(native, 'drawImage');
+ expect(() => cache.draw(ctx, () => {
+ ctx.beginPath();
+ ctx.moveTo(10, 20);
+ ctx.lineTo(64, 20);
+ ctx.stroke();
+ throw new Error('failed repair');
+ }, { left: 0, top: 21, right: 100, bottom: 40 })).toThrow('failed repair');
+ expect(stroke).toHaveBeenCalledOnce();
+ expect(image).not.toHaveBeenCalled();
+
+ line();
+ expect(stroke).toHaveBeenCalledOnce();
+ expect(image).toHaveBeenCalledOnce();
+ expect(ctx._context).toBe(native);
+ });
+
+ it.each([1e-8, -1e-8, 1e-4])('distinguishes Float32 stroke drift from intentional fractional edges: %s', (drift) => {
+ const scale = 1.340000033378601;
+ ctx.setTransform(scale, 0, 0, scale, 0.5, 0.5 + drift);
+ ctx.lineWidth = 0.999999989146616 / scale;
+ const image = vi.spyOn(native, 'drawImage');
+ cache.draw(ctx, () => {
+ ctx.beginPath();
+ ctx.moveTo(10 / scale, 20 / scale);
+ ctx.lineTo(64 / scale, 20 / scale);
+ ctx.stroke();
+ });
+ const paint = (image.mock.calls[0][0] as HTMLCanvasElement).getContext('2d')!;
+ if (Math.abs(drift) < 1e-6) {
+ expect(paint.fillRect).toHaveBeenCalledWith(expect.any(Number), 3, expect.any(Number), 1);
+ expect(paint.stroke).not.toHaveBeenCalled();
+ } else {
+ expect(paint.fillRect).not.toHaveBeenCalled();
+ expect(paint.stroke).toHaveBeenCalledOnce();
+ }
+ });
+
+ it('keeps color, dash, width, fractional phase and physical scale in the bitmap identity', () => {
+ const image = vi.spyOn(native, 'drawImage');
+ line();
+ ctx.strokeStyle = '#be123c';
+ line();
+ ctx.setLineDash([2, 5, 2]);
+ line();
+ ctx.lineWidth = 2;
+ line();
+ ctx.setTransform(1, 0, 0, 1, 0.5, 0.5);
+ line();
+ ctx.setTransform(3, 0, 0, 3, 0.5, 0.5);
+ line();
+
+ const bitmaps = image.mock.calls.map((call) => call[0] as HTMLCanvasElement);
+ expect(new Set(bitmaps).size).toBe(6);
+ expect(bitmaps[5].width).toBeGreaterThan(bitmaps[4].width * 2);
+ expect(bitmaps[5].height).toBeGreaterThan(bitmaps[4].height * 2);
+ });
+
+ it.each(['source-over', 'destination-out'] as const)('preserves %s composition and caller state', (operation) => {
+ ctx.globalCompositeOperation = operation;
+ ctx.globalAlpha = 0.6;
+ ctx.imageSmoothingEnabled = true;
+ ctx.setTransform(2, 0, 0, 2, 4, 8);
+ line();
+
+ expect(native.globalCompositeOperation).toBe(operation);
+ expect(native.globalAlpha).toBe(0.6);
+ expect(native.imageSmoothingEnabled).toBe(true);
+ expect(native.getTransform()).toMatchObject({ a: 2, d: 2, e: 4, f: 8 });
+ });
+
+ it.each(['printing', 'rotation', 'nonuniform', 'shadow', 'large', 'curve'])('retains native drawing for %s', (mode) => {
+ const stroke = vi.spyOn(native, 'stroke');
+ const image = vi.spyOn(native, 'drawImage');
+ if (mode === 'printing') {
+ ctx.__mode = 'printing';
+ } else if (mode === 'rotation') {
+ ctx.setTransform(1, 0.2, 0, 1, 0, 0);
+ } else if (mode === 'nonuniform') {
+ ctx.setTransform(2, 0, 0, 1, 0, 0);
+ } else if (mode === 'shadow') {
+ ctx.shadowBlur = 2;
+ }
+ cache.draw(ctx, () => {
+ ctx.beginPath();
+ ctx.moveToByPrecision(10, 20);
+ ctx.lineToByPrecision(mode === 'large' ? 1_000_000 : 64, 45);
+ if (mode === 'curve') {
+ ctx.arc(30, 30, 5, 0, Math.PI);
+ }
+ ctx.stroke();
+ });
+
+ expect(stroke).toHaveBeenCalledOnce();
+ expect(image).not.toHaveBeenCalled();
+ });
+
+ it('bounds memory and releases retained canvases on disposal', () => {
+ const image = vi.spyOn(native, 'drawImage');
+ for (let i = 0; i < 300; i++) {
+ ctx.strokeStyle = `#${i.toString(16).padStart(6, '0')}`;
+ line();
+ }
+ const bitmaps = image.mock.calls.map((call) => call[0] as HTMLCanvasElement);
+ expect(bitmaps[0].width).toBe(0);
+ expect(bitmaps[bitmaps.length - 1].width).toBeGreaterThan(0);
+ cache.dispose();
+ expect(bitmaps.every((bitmap) => bitmap.width === 0 && bitmap.height === 0)).toBe(true);
+ });
+
+ it('retains a mixed-border working set beyond the default entry limit', () => {
+ cache.dispose();
+ cache = Reflect.get(injector.get(Border), '_strokeCache') as RenderPrimitiveCache;
+ const image = vi.spyOn(native, 'drawImage');
+ const paint = () => cache.draw(ctx, () => {
+ ctx.beginPath();
+ ctx.moveTo(0.5, 0.5);
+ ctx.lineTo(4.5, 0.5);
+ ctx.stroke();
+ });
+ for (let i = 0; i < 512; i++) {
+ ctx.strokeStyle = `#${i.toString(16).padStart(6, '0')}`;
+ paint();
+ }
+ const first = image.mock.calls[0][0] as HTMLCanvasElement;
+ ctx.strokeStyle = '#000000';
+ paint();
+ expect(image.mock.calls[512][0]).toBe(first);
+ expect(first.width).toBeGreaterThan(0);
+
+ ctx.strokeStyle = '#abcdef';
+ paint();
+ expect(first.width).toBe(0);
+ cache.dispose();
+ expect(image.mock.calls.every(([bitmap]) => (bitmap as HTMLCanvasElement).width === 0)).toBe(true);
+ });
+
+ it('keeps the original pixel budget and releases rasters with a larger entry allowance', () => {
+ cache.dispose();
+ cache = Reflect.get(injector.get(Border), '_strokeCache') as RenderPrimitiveCache;
+ const image = vi.spyOn(native, 'drawImage');
+ const paint = () => cache.draw(ctx, () => {
+ ctx.beginPath();
+ ctx.moveTo(0.5, 0.5);
+ ctx.lineTo(10_000.5, 0.5);
+ ctx.stroke();
+ });
+ for (let i = 0; i < 10; i++) {
+ ctx.strokeStyle = `#${i.toString(16).padStart(6, '0')}`;
+ paint();
+ }
+ const bitmaps = image.mock.calls.map(([bitmap]) => bitmap as HTMLCanvasElement);
+ expect(bitmaps[0].width).toBe(0);
+ expect(bitmaps[bitmaps.length - 1].width).toBeGreaterThan(0);
+ expect(bitmaps.reduce((pixels, bitmap) => pixels + bitmap.width * bitmap.height, 0)).toBeLessThanOrEqual(512 * 1024);
+ cache.clear();
+ expect(bitmaps.every((bitmap) => bitmap.width === 0 && bitmap.height === 0)).toBe(true);
+ paint();
+ const afterClear = image.mock.calls[image.mock.calls.length - 1][0] as HTMLCanvasElement;
+ expect(afterClear.width).toBeGreaterThan(0);
+ cache.dispose();
+ cache.dispose();
+ expect(afterClear.width).toBe(0);
+ expect(afterClear.height).toBe(0);
+ expect(ctx._context).toBe(native);
+ });
+
+ it('restores the original native context if drawing throws', () => {
+ expect(() => cache.draw(ctx, () => {
+ throw new Error('failed draw');
+ })).toThrow('failed draw');
+ expect(ctx._context).toBe(native);
+ });
+
+ it('restores raster state when a bitmap submission fails', () => {
+ ctx.setTransform(2, 0, 0, 2, 4, 8);
+ ctx.imageSmoothingEnabled = true;
+ ctx.globalAlpha = 0.6;
+ vi.spyOn(native, 'drawImage').mockImplementation(() => {
+ throw new Error('Bitmap submission failed');
+ });
+ expect(line).toThrow('Bitmap submission failed');
+ expect(ctx._context).toBe(native);
+ expect(native.getTransform()).toMatchObject({ a: 2, d: 2, e: 4, f: 8 });
+ expect(native.imageSmoothingEnabled).toBe(true);
+ expect(native.globalAlpha).toBe(0.6);
+ });
+
+ it.each(['disconnected', 'transformed'])('retains native geometry for a %s path', (mode) => {
+ const stroke = vi.spyOn(native, 'stroke');
+ const image = vi.spyOn(native, 'drawImage');
+ cache.draw(ctx, () => {
+ ctx.beginPath();
+ ctx.moveToByPrecision(10, 20);
+ if (mode === 'disconnected') {
+ ctx.moveToByPrecision(64, 45);
+ } else {
+ ctx.translate(8, 0);
+ ctx.lineToByPrecision(64, 45);
+ }
+ ctx.stroke();
+ });
+ expect(stroke).toHaveBeenCalledOnce();
+ expect(image).not.toHaveBeenCalled();
+ });
+
+ function text(): void {
+ cache.draw(ctx, () => ctx.fillText('Merged title', 10, 20));
+ }
+
+ it('restores text raster state and the caller save stack when a bitmap submission fails', () => {
+ native.save();
+ ctx.setTransform(2, 0, 0, 2, 4, 8);
+ ctx.imageSmoothingEnabled = true;
+ ctx.globalAlpha = 0.6;
+ vi.spyOn(native, 'drawImage').mockImplementation(() => {
+ throw new Error('Text bitmap submission failed');
+ });
+
+ expect(text).toThrow('Text bitmap submission failed');
+ expect(ctx._context).toBe(native);
+ expect(native.getTransform()).toMatchObject({ a: 2, d: 2, e: 4, f: 8 });
+ expect(native.imageSmoothingEnabled).toBe(true);
+ expect(native.globalAlpha).toBe(0.6);
+ native.restore();
+ expect(native.getTransform()).toMatchObject({ a: 1, d: 1, e: 0, f: 0 });
+ });
+
+ it('reuses physical text bitmaps after integral translations and invalidates for color and font changes', () => {
+ const fill = vi.spyOn(native, 'fillText');
+ const image = vi.spyOn(native, 'drawImage');
+ text();
+ ctx.setTransform(1, 0, 0, 1, -162, 100);
+ text();
+ ctx.fillStyle = '#be123c';
+ text();
+ ctx.font = 'bold 16px Arial';
+ text();
+ expect(fill).not.toHaveBeenCalled();
+ expect(image).toHaveBeenCalledTimes(4);
+ expect(image.mock.calls[1][0]).toBe(image.mock.calls[0][0]);
+ expect(new Set(image.mock.calls.map((call) => call[0])).size).toBe(3);
+ });
+
+ it.each(['loadingdone', 'loadingerror', 'metrics'])('repaints glyphs after %s and releases font listeners', (event) => {
+ const image = vi.spyOn(native, 'drawImage');
+ const remove = vi.spyOn(fonts, 'removeEventListener');
+ text();
+ const before = image.mock.calls[0][0] as HTMLCanvasElement;
+ if (event === 'metrics') {
+ FontCache.invalidateMetrics(() => false);
+ } else {
+ fonts.dispatchEvent(new Event(event));
+ }
+ text();
+ expect(before.width).toBe(0);
+ expect(image.mock.calls[1][0]).not.toBe(before);
+ cache.dispose();
+ expect(remove).toHaveBeenCalledTimes(2);
+ });
+
+ it('keeps inherited text language in the raster identity', () => {
+ const container = document.createElement('div');
+ container.lang = 'zh-CN';
+ container.append(native.canvas);
+ const image = vi.spyOn(native, 'drawImage');
+ text();
+ container.lang = 'ja';
+ text();
+ const before = image.mock.calls[0][0] as HTMLCanvasElement;
+ const after = image.mock.calls[1][0] as HTMLCanvasElement;
+ expect(before.lang).toBe('zh-CN');
+ expect(after.lang).toBe('ja');
+ expect(after).not.toBe(before);
+ });
+
+ it.each(['loading', 'maxWidth', 'rotation', 'shadow', 'metrics', 'direction'])('retains native text rendering for %s', (mode) => {
+ const fill = vi.spyOn(native, 'fillText');
+ const image = vi.spyOn(native, 'drawImage');
+ if (mode === 'loading') {
+ fonts.status = 'loading';
+ } else if (mode === 'rotation') {
+ ctx.setTransform(1, 0.2, 0, 1, 0, 0);
+ } else if (mode === 'shadow') {
+ ctx.shadowColor = '#ff0000';
+ } else if (mode === 'metrics') {
+ vi.spyOn(native, 'measureText').mockReturnValue({ width: 10 } as TextMetrics);
+ } else if (mode === 'direction') {
+ ctx.direction = 'inherit';
+ native.canvas.dir = 'auto';
+ }
+ cache.draw(ctx, () => {
+ if (mode === 'maxWidth') {
+ ctx.fillText('Merged title', 10, 20, 12);
+ } else {
+ ctx.fillText('Merged title', 10, 20);
+ }
+ });
+ expect(fill).toHaveBeenCalledOnce();
+ expect(image).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 8f6ae45800..8f75cb4696 100644
--- a/packages/engine-render/src/components/sheets/extensions/background.ts
+++ b/packages/engine-render/src/components/sheets/extensions/background.ts
@@ -19,7 +19,6 @@ import type { UniverRenderingContext } from '../../../context';
import type { IDrawInfo } from '../../extension';
import type { SpreadsheetSkeleton } from '../sheet.render-skeleton';
import type { Spreadsheet } from '../spreadsheet';
-import { Range } from '@univerjs/core';
import { fixLineWidthByScale, getColor, inViewRanges } from '../../../basics/tools';
import { SpreadsheetExtensionRegistry } from '../../extension';
import { SheetExtension } from './sheet-extension';
@@ -33,10 +32,66 @@ 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);
+// ObjectMatrix size counts rows; choose work within each damaged row instead of scanning every cached cell.
+function forEachCachedBackground(
+ matrix: ObjectMatrix<string>,
+ ranges: IRange[],
+ visit: (row: number, col: number, value: string) => void
+): void {
+ let cachedRows: number[] | undefined;
+ for (const range of ranges) {
+ const visitRow = (row: number) => {
+ const values = matrix.getRow(row);
+ if (!values) {
+ return;
+ }
+ const visitColumn = (col: number) => {
+ const value = values[col];
+ if (value) {
+ visit(row, col, value);
+ }
+ };
+ const width = range.endColumn - range.startColumn + 1;
+ if (width <= 32) {
+ for (let col = range.startColumn; col <= range.endColumn; col++) {
+ visitColumn(col);
+ }
+ } else {
+ const columns = Object.keys(values);
+ if (width < columns.length) {
+ for (let col = range.startColumn; col <= range.endColumn; col++) {
+ visitColumn(col);
+ }
+ } else {
+ for (const column of columns) {
+ const col = Number(column);
+ if (col >= range.startColumn && col <= range.endColumn) {
+ visitColumn(col);
+ }
+ }
+ }
+ }
+ };
+ const height = range.endRow - range.startRow + 1;
+ if (height <= 32) {
+ for (let row = range.startRow; row <= range.endRow; row++) {
+ visitRow(row);
+ }
+ } else {
+ cachedRows ??= Object.keys(matrix.getMatrix()).map(Number);
+ if (height < cachedRows.length) {
+ for (let row = range.startRow; row <= range.endRow; row++) {
+ visitRow(row);
+ }
+ } else {
+ for (const row of cachedRows) {
+ if (row >= range.startRow && row <= range.endRow) {
+ visitRow(row);
+ }
+ }
+ }
+ }
+ }
}
interface IRenderBGContext {
@@ -54,6 +109,8 @@ interface IRenderBGContext {
}
export class Background extends SheetExtension {
+ override readonly viewportCacheReusable = this.constructor === Background;
+
override uKey = UNIQUE_KEY;
override Z_INDEX = DOC_EXTENSION_Z_INDEX;
@@ -131,21 +188,9 @@ export class Background extends SheetExtension {
renderBGContext.backgroundPaths = backgroundPaths;
ctx.beginPath();
- const matrixSize = bgColorMatrix.getSizeOf();
- 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 render range.
- if (cellCountInRanges < matrixSize) {
- // 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);
- }
+ renderBGContext.skipRenderRangeCheck = true;
+ forEachCachedBackground(bgColorMatrix, renderRanges, rangeForEachFn);
+ renderBGContext.skipRenderRangeCheck = false;
ctx.fill(backgroundPaths);
ctx.closePath();
};
diff --git a/packages/engine-render/src/components/sheets/extensions/border-row-cache.ts b/packages/engine-render/src/components/sheets/extensions/border-row-cache.ts
new file mode 100644
index 0000000000..d164803ee2
--- /dev/null
+++ b/packages/engine-render/src/components/sheets/extensions/border-row-cache.ts
@@ -0,0 +1,193 @@
+/**
+ * Copyright 2023-present DreamNum Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import type { IRange } from '@univerjs/core';
+import { BorderStyleTypes, Disposable } from '@univerjs/core';
+import type { IBorderCacheItem } from '../interfaces';
+import type { SpreadsheetSkeleton } from '../sheet.render-skeleton';
+import { BORDER_TYPE, COLOR_BLACK_RGB } from '../../../basics/const';
+import { UniverRenderingContext } from '../../../context';
+
+const MAX_ENTRIES = 128;
+const MAX_COMMANDS = 16 * 1024;
+const MAX_ROW_COMMANDS = 1024;
+const PIXEL_METHODS = new Set(['stroke', 'fill', 'fillRect', 'strokeRect', 'clearRect', 'fillText', 'strokeText', 'putImageData', 'clip', 'reset', 'drawFocusIfNeeded']);
+
+interface IBorderBlit {
+ canvas: HTMLCanvasElement;
+ x: number;
+ y: number;
+ width: number;
+ height: number;
+}
+
+/** Reuse native edge blits, preserving their order and individual alpha/clip composition. */
+export class BorderRowCache extends Disposable {
+ private readonly _rows = new Map<string, IBorderBlit[]>();
+ private _commands = 0;
+
+ draw(
+ ctx: UniverRenderingContext,
+ skeleton: SpreadsheetSkeleton,
+ row: number,
+ range: IRange,
+ resolveColor: (color: string) => string,
+ paint: (target: UniverRenderingContext) => void
+ ): boolean {
+ const native = ctx._context;
+ const borderRow = skeleton.stylesCache.border?.getRow(row);
+ if (ctx.__mode === 'printing' || !native || typeof document === 'undefined'
+ || range.endColumn - range.startColumn < 7 || range.endColumn - range.startColumn >= 256
+ || !borderRow || !skeleton.worksheet.getRowVisible(row) || skeleton.overflowCache.getRow(row)
+ || native.globalAlpha !== 1 || native.globalCompositeOperation !== 'source-over'
+ || native.shadowBlur || native.shadowOffsetX || native.shadowOffsetY
+ || !['rgba(0, 0, 0, 0)', 'transparent', '#00000000'].includes(native.shadowColor)
+ || (native.filter && native.filter !== 'none')
+ || (native.getContextAttributes?.()?.colorSpace ?? 'srgb') !== 'srgb') {
+ return false;
+ }
+ const m = native.getTransform();
+ if (m.a !== m.d || m.a <= 0 || m.b || m.c) {
+ return false;
+ }
+ const startY = row === 0 ? 0 : skeleton.rowHeightAccumulation[row - 1];
+ const endY = skeleton.rowHeightAccumulation[row];
+ if ((endY - startY) * m.d > 12 || endY <= startY) {
+ return false;
+ }
+ const startX = range.startColumn === 0 ? 0 : skeleton.columnWidthAccumulation[range.startColumn - 1];
+ const endX = skeleton.columnWidthAccumulation[range.endColumn];
+ const left = Math.floor(Math.round(startX * m.a) + m.e);
+ const top = Math.floor(Math.round(startY * m.d) + m.f);
+ const width = Math.round(endX * m.a) - Math.round(startX * m.a);
+ const height = Math.round(endY * m.d) - Math.round(startY * m.d);
+ if (!Number.isFinite(width * height)) {
+ return false;
+ }
+ const identity: unknown[] = [m.a, m.e - left, m.f + Math.round(startY * m.d) - top, width, height, native.lineCap, native.lineJoin, native.miterLimit];
+ let edges = 0;
+ let rowColor: string | undefined;
+ for (let col = range.startColumn; col <= range.endColumn; col++) {
+ const cell = skeleton.getCellWithCoordByIndex(row, col, false);
+ if (cell.isMerged || cell.isMergedMainCell || !skeleton.worksheet.getColVisible(col)) {
+ return false;
+ }
+ const border = borderRow[col];
+ for (const key in border) {
+ const item = border[key] as IBorderCacheItem;
+ if (!item || item.style !== BorderStyleTypes.THIN
+ || ![BORDER_TYPE.TOP, BORDER_TYPE.BOTTOM, BORDER_TYPE.LEFT, BORDER_TYPE.RIGHT].includes(item.type)) {
+ return false;
+ }
+ const color = resolveColor(item.color || COLOR_BLACK_RGB);
+ if (!/^#(?:[\da-f]{3}|[\da-f]{6})$/i.test(color) || (rowColor !== undefined && rowColor !== color)) {
+ return false;
+ }
+ rowColor = color;
+ identity.push(color);
+ edges++;
+ }
+ identity.push(Math.round(cell.startX * m.a) + m.e - left, Math.round(cell.endX * m.a) + m.e - left, border);
+ }
+ if (edges < 16 || edges > MAX_ROW_COMMANDS) {
+ return false;
+ }
+ const key = JSON.stringify(identity);
+ let commands = this._rows.get(key);
+ if (commands && commands.some((item) => item.canvas.width !== item.width || item.canvas.height !== item.height)) {
+ this._commands -= commands.length;
+ this._rows.delete(key);
+ return false;
+ }
+ if (!commands) {
+ const captured: IBorderBlit[] = [];
+ let unsupported = false;
+ const methods = new Map<PropertyKey, (...args: unknown[]) => unknown>();
+ const capture = new Proxy(native, {
+ get: (target, property) => {
+ if (property === 'drawImage') {
+ return (canvas: HTMLCanvasElement, x: number, y: number, ...rest: unknown[]) => {
+ const transform = target.getTransform();
+ if (rest.length || !canvas?.width || !canvas.height || typeof canvas.getContext !== 'function'
+ || !Number.isFinite(x + y) || captured.length >= MAX_ROW_COMMANDS
+ || transform.a !== 1 || transform.d !== 1 || transform.b || transform.c || transform.e || transform.f
+ || target.globalAlpha !== 1 || target.globalCompositeOperation !== 'source-over') {
+ unsupported = true;
+ return;
+ }
+ captured.push({ canvas, x: x - left, y: y - top, width: canvas.width, height: canvas.height });
+ };
+ }
+ if (PIXEL_METHODS.has(String(property))) {
+ return () => {
+ unsupported = true;
+ };
+ }
+ const value = Reflect.get(target, property, target);
+ if (typeof value !== 'function') {
+ return value;
+ }
+ let method = methods.get(property);
+ if (!method) {
+ method = value.bind(target);
+ methods.set(property, method!);
+ }
+ return method;
+ },
+ set: (target, property, value) => Reflect.set(target, property, value, target),
+ });
+ ctx.save();
+ try {
+ paint(new UniverRenderingContext(capture, { canvasColorService: { getRenderColor: resolveColor } }));
+ } finally {
+ ctx.restore();
+ }
+ if (unsupported || !captured.length
+ || captured.some((item) => item.canvas.width !== item.width || item.canvas.height !== item.height)) {
+ return false;
+ }
+ commands = captured;
+ while (this._rows.size && (this._rows.size >= MAX_ENTRIES || this._commands + commands.length > MAX_COMMANDS)) {
+ const oldest = this._rows.keys().next().value!;
+ this._commands -= this._rows.get(oldest)!.length;
+ this._rows.delete(oldest);
+ }
+ this._rows.set(key, commands);
+ this._commands += commands.length;
+ }
+ ctx.save();
+ try {
+ ctx.setTransform(1, 0, 0, 1, 0, 0);
+ ctx.imageSmoothingEnabled = false;
+ for (const command of commands) {
+ ctx.drawImage(command.canvas, command.x + left, command.y + top);
+ }
+ } finally {
+ ctx.restore();
+ }
+ return true;
+ }
+
+ clear(): void {
+ this._rows.clear();
+ this._commands = 0;
+ }
+
+ override dispose(): void {
+ this.clear();
+ super.dispose();
+ }
+}
diff --git a/packages/engine-render/src/components/sheets/extensions/border.ts b/packages/engine-render/src/components/sheets/extensions/border.ts
index 7e68af8ff6..96e0900754 100644
--- a/packages/engine-render/src/components/sheets/extensions/border.ts
+++ b/packages/engine-render/src/components/sheets/extensions/border.ts
@@ -15,18 +15,21 @@
*/
import type { IRange, IScale, ObjectMatrix } from '@univerjs/core';
+import { BorderStyleTypes } from '@univerjs/core';
import type { UniverRenderingContext } from '../../../context';
import type { IDrawInfo } from '../../extension';
import type { IBorderCache, IBorderCacheItem } from '../interfaces';
import type { SpreadsheetSkeleton } from '../sheet.render-skeleton';
-import { BorderStyleTypes, Range } from '@univerjs/core';
import { BORDER_TYPE, COLOR_BLACK_RGB, FIX_ONE_PIXEL_BLUR_OFFSET } from '../../../basics/const';
import { drawDiagonalLineByBorderType, drawLineByBorderType, getLineWidth, setLineType } from '../../../basics/draw';
import { SpreadsheetExtensionRegistry } from '../../extension';
+import { BorderRowCache } from './border-row-cache';
+import { RenderPrimitiveCache } from './render-primitive-cache';
import { SheetExtension } from './sheet-extension';
const UNIQUE_KEY = 'DefaultBorderExtension';
const BORDER_Z_INDEX = 50;
+const BORDER_PRIMITIVE_CACHE_ENTRIES = 512;
interface IRenderBorderContext {
ctx: UniverRenderingContext;
@@ -36,9 +39,14 @@ interface IRenderBorderContext {
spreadsheetSkeleton: SpreadsheetSkeleton;
diffRanges: IRange[];
viewRanges: IRange[];
+ lineStyle?: BorderStyleTypes;
+ lineWidth?: number;
+ lineColor?: string;
}
export class Border extends SheetExtension {
+ override readonly viewportCacheReusable = this.constructor === Border;
+
override uKey = UNIQUE_KEY;
override Z_INDEX = BORDER_Z_INDEX;
@@ -46,6 +54,20 @@ export class Border extends SheetExtension {
preStyle: BorderStyleTypes;
preColor: string;
+ private readonly _strokeCache = new RenderPrimitiveCache(BORDER_PRIMITIVE_CACHE_ENTRIES);
+ private readonly _rowCache = new BorderRowCache();
+
+ override clearCache(): void {
+ this._strokeCache.clear();
+ this._rowCache.clear();
+ }
+
+ override dispose(): void {
+ this._strokeCache.dispose();
+ this._rowCache.dispose();
+ super.dispose();
+ }
+
override draw(
ctx: UniverRenderingContext,
_parentScale: IScale,
@@ -81,18 +103,55 @@ export class Border extends SheetExtension {
viewRanges,
spreadsheetSkeleton,
} as IRenderBorderContext;
+ const colors = new Map<string, string>();
+ const resolveColor = (color: string): string => {
+ let resolved = colors.get(color);
+ if (resolved === undefined) {
+ ctx.save();
+ ctx.strokeStyle = color;
+ resolved = ctx.strokeStyle as string;
+ ctx.restore();
+ colors.set(color, resolved);
+ }
+ return resolved;
+ };
- ctx.beginPath();
- viewRanges.forEach((range) => {
- Range.foreach(range, (row, col) => {
- const borderConfig = border.getValue(row, col);
- if (borderConfig) {
- this.renderBorderByCell(renderBorderContext, row, col, borderConfig);
- }
+ const paint = () => {
+ this._strokeCache.draw(ctx, () => {
+ ctx.beginPath();
+ viewRanges.forEach((range) => {
+ for (let row = range.startRow; row <= range.endRow; row++) {
+ const paintRow = (target: UniverRenderingContext) => {
+ const context = target === ctx
+ ? renderBorderContext
+ : {
+ ...renderBorderContext,
+ ctx: target,
+ lineStyle: undefined,
+ lineWidth: undefined,
+ lineColor: undefined,
+ };
+ for (let col = range.startColumn; col <= range.endColumn; col++) {
+ const borderConfig = border.getValue(row, col);
+ if (borderConfig) {
+ this.renderBorderByCell(context, row, col, borderConfig);
+ }
+ }
+ };
+ if (!this.isRenderDiffRangesByRow(row, row, diffRanges)
+ || !this._rowCache.draw(ctx, spreadsheetSkeleton, row, range, resolveColor, (target) => this._strokeCache.draw(target, () => paintRow(target)))) {
+ paintRow(ctx);
+ }
+ }
+ });
+ ctx.closePath();
});
- });
-
- ctx.closePath();
+ };
+ if (this.constructor === Border) {
+ ctx.withCachedScale(paint);
+ } else {
+ paint();
+ }
ctx.restore();
}
@@ -128,7 +187,9 @@ export class Border extends SheetExtension {
let startX = cellStartX;
let endX = cellEndX;
- if (type !== BORDER_TYPE.TOP && type !== BORDER_TYPE.BOTTOM && type !== BORDER_TYPE.LEFT && type !== BORDER_TYPE.RIGHT) {
+ const isDiagonal = type !== BORDER_TYPE.TOP && type !== BORDER_TYPE.BOTTOM
+ && type !== BORDER_TYPE.LEFT && type !== BORDER_TYPE.RIGHT;
+ if (isDiagonal) {
if (isMerged) {
continue;
}
@@ -141,17 +202,29 @@ export class Border extends SheetExtension {
}
}
- const lineWidth = getLineWidth(style);
- setLineType(ctx, style);
- ctx.setLineWidthByPrecision(lineWidth);
- ctx.strokeStyle = color || COLOR_BLACK_RGB;
+ let lineWidth = renderBorderContext.lineWidth;
+ if (renderBorderContext.lineStyle !== style || lineWidth === undefined) {
+ lineWidth = getLineWidth(style);
+ setLineType(ctx, style);
+ ctx.setLineWidthByPrecision(lineWidth);
+ renderBorderContext.lineStyle = style;
+ renderBorderContext.lineWidth = lineWidth;
+ }
+ const lineColor = color || COLOR_BLACK_RGB;
+ if (renderBorderContext.lineColor !== lineColor) {
+ ctx.strokeStyle = lineColor;
+ renderBorderContext.lineColor = lineColor;
+ }
- drawDiagonalLineByBorderType(ctx, style, type, {
- startX,
- startY,
- endX,
- endY,
- });
+ if (isDiagonal) {
+ drawDiagonalLineByBorderType(ctx, style, type, {
+ startX,
+ startY,
+ endX,
+ endY,
+ });
+ continue;
+ }
if (this._getOverflowExclusion(overflowCache, type, row, col)) {
continue;
@@ -186,30 +259,21 @@ export class Border extends SheetExtension {
borderRow: number,
borderColumn: number
) {
- let isDraw = false;
if (type === BORDER_TYPE.TOP || type === BORDER_TYPE.BOTTOM) {
- return isDraw;
+ return false;
}
-
- overflowCache?.forRow((row, rowArray) => {
- if (row !== borderRow) {
+ const row = overflowCache?.getRow(borderRow);
+ if (!row) {
+ return false;
+ }
+ for (const column in row) {
+ const { startColumn, endColumn } = row[column];
+ if ((type === BORDER_TYPE.LEFT && borderColumn > startColumn && borderColumn <= endColumn)
+ || (type === BORDER_TYPE.RIGHT && borderColumn >= startColumn && borderColumn < endColumn)) {
return true;
}
- rowArray.forEach((column) => {
- const rectangle = overflowCache.getValue(row, column)!;
- const { startColumn, endColumn } = rectangle;
- if (type === BORDER_TYPE.LEFT && borderColumn > startColumn && borderColumn <= endColumn) {
- isDraw = true;
- return false;
- }
-
- if (type === BORDER_TYPE.RIGHT && borderColumn >= startColumn && borderColumn < endColumn) {
- isDraw = true;
- return false;
- }
- });
- });
- return isDraw;
+ }
+ return false;
}
// eslint-disable-next-line
diff --git a/packages/engine-render/src/components/sheets/extensions/column-header-layout.ts b/packages/engine-render/src/components/sheets/extensions/column-header-layout.ts
index 1e34023129..9821f54f24 100644
--- a/packages/engine-render/src/components/sheets/extensions/column-header-layout.ts
+++ b/packages/engine-render/src/components/sheets/extensions/column-header-layout.ts
@@ -15,10 +15,10 @@
*/
import type { IScale } from '@univerjs/core';
+import { numberToABC } from '@univerjs/core';
import type { UniverRenderingContext } from '../../../context';
import type { IAColumnCfg, IAColumnCfgObj, IHeaderStyleCfg } from '../interfaces';
import type { SpreadsheetSkeleton } from '../sheet.render-skeleton';
-import { numberToABC } from '@univerjs/core';
import { DEFAULT_FONTFACE_PLANE, FIX_ONE_PIXEL_BLUR_OFFSET, MIDDLE_CELL_POS_MAGIC_NUMBER } from '../../../basics/const';
import { getColor } from '../../../basics/tools';
import { SheetColumnHeaderExtensionRegistry } from '../../extension';
@@ -53,6 +53,8 @@ const DEFAULT_PRINTING_COLUMN_STYLE = {
* Column Header Bar, include a lot of columns header
*/
export class ColumnHeaderLayout extends SheetExtension {
+ override readonly viewportCacheReusable = this.constructor === ColumnHeaderLayout;
+
override uKey = UNIQUE_KEY;
override Z_INDEX = 10;
// The workbook columns configuration and header style
diff --git a/packages/engine-render/src/components/sheets/extensions/custom.ts b/packages/engine-render/src/components/sheets/extensions/custom.ts
index c529361338..a42893e711 100644
--- a/packages/engine-render/src/components/sheets/extensions/custom.ts
+++ b/packages/engine-render/src/components/sheets/extensions/custom.ts
@@ -15,9 +15,9 @@
*/
import type { IRange, IScale } from '@univerjs/core';
+import { Range, sortRules } from '@univerjs/core';
import type { UniverRenderingContext } from '../../../context';
import type { SpreadsheetSkeleton } from '../sheet.render-skeleton';
-import { Range, sortRules } from '@univerjs/core';
import { SpreadsheetExtensionRegistry } from '../../extension';
import { SheetExtension } from './sheet-extension';
@@ -31,6 +31,8 @@ const stringifyRange = (range: IRange) => {
};
export class Custom extends SheetExtension {
+ override viewportCacheReusable = this.constructor === Custom;
+
protected override Z_INDEX = Z_INDEX;
override uKey: string = UNIQUE_KEY;
@@ -95,6 +97,10 @@ export class Custom extends SheetExtension {
unitId: worksheet.unitId,
};
+ if (cellData.customRender.length > 0) {
+ // User painters can depend on time or external state without dirtying the sheet.
+ this.viewportCacheReusable = false;
+ }
const customRender = cellData.customRender.sort(sortRules);
ctx.save();
diff --git a/packages/engine-render/src/components/sheets/extensions/font.ts b/packages/engine-render/src/components/sheets/extensions/font.ts
index 6ef6532490..93fd3379f2 100644
--- a/packages/engine-render/src/components/sheets/extensions/font.ts
+++ b/packages/engine-render/src/components/sheets/extensions/font.ts
@@ -46,6 +46,7 @@ import { SpreadsheetExtensionRegistry } from '../../extension';
import { EXPAND_SIZE_FOR_RENDER_OVERFLOW, FONT_EXTENSION_Z_INDEX, shouldRenderRowText } from '../constants';
import { DEFAULT_PADDING_DATA, FULL_WIDTH_HORIZONTAL_ALIGNMENTS, getDocsSkeletonPageSize } from '../sheet.render-skeleton';
import { calculateCellImageRect } from '../util';
+import { RenderPrimitiveCache } from './render-primitive-cache';
import { SheetExtension } from './sheet-extension';
const UNIQUE_KEY = 'DefaultFontExtension';
@@ -122,12 +123,29 @@ interface IRenderFontContext {
}
export class Font extends SheetExtension {
+ override readonly viewportCacheReusable = this.constructor === Font;
+
override uKey = UNIQUE_KEY;
override Z_INDEX = FONT_EXTENSION_Z_INDEX;
private _imageFallback = new Image();
+ private readonly _primitiveCache = new RenderPrimitiveCache();
+
+ override clearCache(): void {
+ this._primitiveCache.clear();
+ }
+
+ override dispose(): void {
+ this._imageFallback.onload = null;
+ this._primitiveCache.dispose();
+ super.dispose();
+ }
constructor() {
super();
+ this._imageFallback.onload = () => {
+ this._imageFallback.onload = null;
+ this.parent?.makeDirty(true);
+ };
this._imageFallback.src = IMAGE_FALLBACK_SRC;
}
@@ -136,6 +154,29 @@ export class Font extends SheetExtension {
return parent?.getDocuments();
}
+ getNativeTextClipRepairRanges(skeleton: SpreadsheetSkeleton): IRange[] {
+ const ranges: IRange[] = [];
+ skeleton.nativeTextClipCache.forValue((row, column) => {
+ const cell = skeleton.getCellWithCoordByIndex(row, column, false);
+ const range = skeleton.overflowCache.getValue(row, column)
+ ?? (cell.isMerged || cell.isMergedMainCell
+ ? cell.mergeInfo
+ : {
+ startRow: row,
+ endRow: row,
+ startColumn: column,
+ endColumn: column,
+ });
+ ranges.push({
+ startRow: range.startRow,
+ endRow: range.endRow,
+ startColumn: range.startColumn,
+ endColumn: range.endColumn,
+ });
+ });
+ return ranges;
+ }
+
/**
* Safely draw fallback image, checking if it's fully loaded first.
* If not loaded, draw a simple gray rectangle as placeholder.
@@ -184,6 +225,28 @@ export class Font extends SheetExtension {
endColumn: range.endColumn + EXPAND_SIZE_FOR_RENDER_OVERFLOW,
}, lastRowIndex, lastColIndex));
const rangesToScan = fontRenderRanges?.length ? fontRenderRanges : expandedViewRanges;
+ const verticalOverflow = ctx.__mode !== 'printing' && moreBoundsInfo.textClipBound
+ ? spreadsheetSkeleton.getPlainTextVerticalOverflow(moreBoundsInfo.viewBound)
+ : 0;
+ const sourceRange = verticalOverflow ? spreadsheetSkeleton.getRangeByViewBound(moreBoundsInfo.viewBound) : null;
+ const expandPlainTextRows = (range: IRange): IRange => {
+ if (!verticalOverflow || !sourceRange) return range;
+ const top = rowHeightAccumulation[range.startRow - 1] ?? 0;
+ const bottom = rowHeightAccumulation[range.endRow] ?? top;
+ const rows = spreadsheetSkeleton.getRangeByViewBound({
+ left: 0,
+ right: 0,
+ top: Math.floor(top - verticalOverflow) - 1 + spreadsheetSkeleton.columnHeaderHeightAndMarginTop,
+ bottom: Math.ceil(bottom + verticalOverflow) + 1 + spreadsheetSkeleton.columnHeaderHeightAndMarginTop,
+ });
+ return {
+ ...range,
+ startRow: Math.max(sourceRange.startRow, rows.startRow),
+ endRow: Math.min(sourceRange.endRow, rows.endRow),
+ };
+ };
+ const plainTextRanges = verticalOverflow ? (diffRanges.length ? diffRanges : rangesToScan).map(expandPlainTextRows) : [];
+ const extraPlainCells = verticalOverflow ? new Set<string>() : null;
const renderFontContext = {
ctx,
scale,
@@ -193,10 +256,12 @@ export class Font extends SheetExtension {
rowTotalHeight,
viewRanges: fontRenderRanges?.length ? viewRanges : expandedViewRanges,
checkOutOfViewBound: checkOutOfViewBound || true,
- diffRanges,
+ diffRanges: verticalOverflow ? plainTextRanges : diffRanges,
spreadsheetSkeleton,
} as IRenderFontContext;
ctx.save();
+ const deviceClip = ctx.__mode === 'printing' ? undefined : moreBoundsInfo.textClipBound;
+ const transform = deviceClip ? ctx.getTransform() : undefined;
const mergeData = spreadsheetSkeleton.worksheet.getMergeData();
const hasMerge = mergeData.length > 0;
@@ -225,7 +290,8 @@ export class Font extends SheetExtension {
}
const { startRow, endRow, startColumn, endColumn } = range;
- for (let row = startRow; row <= endRow; row++) {
+ const scan = expandPlainTextRows(range);
+ for (let row = scan.startRow; row <= scan.endRow; row++) {
const rowStartPosition = rowHeightAccumulation[row - 1] ?? 0;
const rowEndPosition = rowHeightAccumulation[row] ?? rowStartPosition;
const rowGap = spreadsheetSkeleton.gapConfig?.rowGaps?.[row]?.size ?? 0;
@@ -239,17 +305,47 @@ export class Font extends SheetExtension {
if (!fontCache) {
continue;
}
+ if (row < startRow || row > endRow) {
+ // Only uncropped plain text can contribute ink from these source rows.
+ if (inViewRanges(rangesToScan, row, col) || !inViewRanges(plainTextRanges, row, col)
+ || !this._canRenderPlainTextWithoutClip(fontCache)) {
+ continue;
+ }
+ const key = `${row}:${col}`;
+ if (extraPlainCells?.has(key)) continue;
+ extraPlainCells?.add(key);
+ }
if (spanModel && spanModel.getMergeDataIndex(row, col) !== -1) {
continue;
}
+ if (deviceClip && transform && transform.a > 0 && transform.d > 0 && !transform.b && !transform.c
+ && !fontCache.documentSkeleton && !fontCache.vertexAngle && !fontCache.centerAngle
+ && fontCache.textFitsCurrentCell === false && !fontCache.cellData?.fontRenderExtension) {
+ const overflow = spreadsheetSkeleton.overflowCache.getValue(row, col);
+ if (overflow) {
+ // Plain overflowing text is clipped to these cells. Keep a physical ink halo at the damage edge.
+ const left = (columnWidthAccumulation[Math.min(col, overflow.startColumn) - 1] ?? 0) * transform.a + transform.e;
+ const right = columnWidthAccumulation[Math.max(col, overflow.endColumn)] * transform.a + transform.e;
+ const top = (rowHeightAccumulation[Math.min(row, overflow.startRow) - 1] ?? 0) * transform.d + transform.f;
+ const bottom = rowHeightAccumulation[Math.max(row, overflow.endRow)] * transform.d + transform.f;
+ if (right + 2 < deviceClip.left || left - 2 > deviceClip.right
+ || bottom + 2 < deviceClip.top || top - 2 > deviceClip.bottom) {
+ continue;
+ }
+ }
+ }
const cellInfo = spreadsheetSkeleton.getCellWithCoordByIndex(row, col, false);
if (!cellInfo) {
continue;
}
renderFontContext.cellInfo = cellInfo;
- this._renderFontEachCell(renderFontContext, row, col, fontMatrix, fontCache);
+ if (fontCache.documentSkeleton || moreBoundsInfo.textClipBound) {
+ this._primitiveCache.draw(ctx, () => this._renderFontEachCell(renderFontContext, row, col, fontMatrix, fontCache), fontCache.documentSkeleton ? undefined : moreBoundsInfo.textClipBound);
+ } else {
+ this._renderFontEachCell(renderFontContext, row, col, fontMatrix, fontCache);
+ }
}
}
});
@@ -262,7 +358,7 @@ export class Font extends SheetExtension {
const cellInfo = spreadsheetSkeleton.getCellWithCoordByIndex(range.startRow, range.startColumn, false);
renderFontContext.cellInfo = cellInfo;
- this._renderFontEachCell(renderFontContext, range.startRow, range.startColumn, fontMatrix, fontCache);
+ this._primitiveCache.draw(ctx, () => this._renderFontEachCell(renderFontContext, range.startRow, range.startColumn, fontMatrix, fontCache));
});
ctx.restore();
@@ -410,7 +506,7 @@ export class Font extends SheetExtension {
return false;
};
- private _renderPlainTextWithoutClip(ctx: UniverRenderingContext, renderFontCtx: IRenderFontContext, fontCache: IFontCacheItem) {
+ private _canRenderPlainTextWithoutClip(fontCache: IFontCacheItem): boolean {
const { cellData, documentSkeleton, textFitsCurrentCell, vertexAngle = 0, centerAngle = 0, wrapStrategy } = fontCache;
if (!textFitsCurrentCell) {
return false;
@@ -434,6 +530,12 @@ export class Font extends SheetExtension {
return false;
}
+ return true;
+ }
+
+ private _renderPlainTextWithoutClip(ctx: UniverRenderingContext, renderFontCtx: IRenderFontContext, fontCache: IFontCacheItem) {
+ if (!this._canRenderPlainTextWithoutClip(fontCache)) return false;
+ const cellData = fontCache.cellData!;
const padding = fontCache.style?.pd ?? DEFAULT_PADDING_DATA;
const paddingLeft = padding.l ?? DEFAULT_PADDING_DATA.l;
const paddingRight = padding.r ?? DEFAULT_PADDING_DATA.r;
diff --git a/packages/engine-render/src/components/sheets/extensions/marker.ts b/packages/engine-render/src/components/sheets/extensions/marker.ts
index eb3825143b..5696b1437c 100644
--- a/packages/engine-render/src/components/sheets/extensions/marker.ts
+++ b/packages/engine-render/src/components/sheets/extensions/marker.ts
@@ -40,6 +40,8 @@ function drawTriangleMarker(ctx: UniverRenderingContext, color: string, x: numbe
}
export class Marker extends SheetExtension {
+ override readonly viewportCacheReusable = this.constructor === Marker;
+
protected override Z_INDEX: number = Z_INDEX;
override uKey: string = UNIQUE_KEY;
diff --git a/packages/engine-render/src/components/sheets/extensions/render-primitive-cache.ts b/packages/engine-render/src/components/sheets/extensions/render-primitive-cache.ts
new file mode 100644
index 0000000000..14c7cd7116
--- /dev/null
+++ b/packages/engine-render/src/components/sheets/extensions/render-primitive-cache.ts
@@ -0,0 +1,454 @@
+/**
+ * Copyright 2023-present DreamNum Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import { Disposable } from '@univerjs/core';
+import type { IBoundRectNoAngle } from '../../../basics/vector2';
+import type { UniverRenderingContext } from '../../../context';
+import { createCanvasElement } from '../../../basics/tools';
+import { FontCache } from '../../docs/layout/shaping-engine/font-cache';
+
+const MAX_ENTRIES = 128;
+const MAX_PIXELS = 512 * 1024;
+const MAX_STROKE_PIXELS = 128 * 1024;
+
+interface IStrokePath {
+ points: Array<[number, number]>;
+ closed: boolean;
+ unsupported: boolean;
+}
+
+interface IStrokeBitmap {
+ canvas: HTMLCanvasElement;
+ pixels: number;
+ offsetX?: number;
+ offsetY?: number;
+}
+
+const TEXT_PROPERTIES = [
+ 'lang',
+ 'font',
+ 'textAlign',
+ 'textBaseline',
+ 'direction',
+ 'fontKerning',
+ 'fontStretch',
+ 'fontVariantCaps',
+ 'letterSpacing',
+ 'wordSpacing',
+ 'textRendering',
+] as const;
+
+/** Rasterize at a stable local origin, retaining the native physical resolution and antialiasing. */
+export class RenderPrimitiveCache extends Disposable {
+ private readonly _bitmaps = new Map<string, IStrokeBitmap>();
+ private _contexts = new WeakMap<CanvasRenderingContext2D, CanvasRenderingContext2D>();
+ private _pixels = 0;
+ private _fontRevision = -1;
+ private _fonts?: FontFaceSet;
+ private _textClipBound?: IBoundRectNoAngle;
+ private _textClipRepairCanvas?: HTMLCanvasElement;
+
+ constructor(private readonly _maxEntries = MAX_ENTRIES) {
+ super();
+ }
+
+ draw(ctx: UniverRenderingContext, draw: () => void, textClipBound?: IBoundRectNoAngle): void {
+ const original = ctx._context;
+ const colorSpace = original?.getContextAttributes?.()?.colorSpace;
+ if (ctx.__mode === 'printing' || !original || typeof document === 'undefined'
+ || (colorSpace && colorSpace !== 'srgb')) {
+ draw();
+ return;
+ }
+ const previousTextClipBound = this._textClipBound;
+ this._textClipBound = textClipBound;
+ ctx._context = this._getContext(original);
+ try {
+ draw();
+ } finally {
+ ctx._context = original;
+ this._textClipBound = previousTextClipBound;
+ }
+ }
+
+ clear(): void {
+ for (const bitmap of this._bitmaps.values()) {
+ bitmap.canvas.width = 0;
+ bitmap.canvas.height = 0;
+ }
+ this._bitmaps.clear();
+ this._contexts = new WeakMap();
+ this._pixels = 0;
+ if (this._textClipRepairCanvas) {
+ this._textClipRepairCanvas.width = 0;
+ this._textClipRepairCanvas.height = 0;
+ this._textClipRepairCanvas = undefined;
+ }
+ }
+
+ override dispose(): void {
+ this.clear();
+ super.dispose();
+ }
+
+ private _getContext(native: CanvasRenderingContext2D): CanvasRenderingContext2D {
+ const existing = this._contexts.get(native);
+ if (existing) {
+ return existing;
+ }
+ const path: IStrokePath = { points: [], closed: false, unsupported: false };
+ const methods = new Map<PropertyKey, (...args: unknown[]) => unknown>();
+ const proxy = new Proxy(native, {
+ get: (target, key) => {
+ const value: unknown = Reflect.get(target, key, target);
+ if (typeof value !== 'function') {
+ return value;
+ }
+ const cached = methods.get(key);
+ if (cached) {
+ return cached;
+ }
+ let method = value.bind(target) as (...args: unknown[]) => unknown;
+ if (key === 'beginPath') {
+ method = () => {
+ path.points.length = 0;
+ path.closed = false;
+ path.unsupported = false;
+ target.beginPath();
+ };
+ } else if (key === 'moveTo' || key === 'lineTo') {
+ method = (...args) => {
+ if (key === 'moveTo' && path.points.length) {
+ path.unsupported = true;
+ }
+ path.points.push([args[0] as number, args[1] as number]);
+ Reflect.apply(value, target, args);
+ };
+ } else if (key === 'closePath') {
+ method = () => {
+ if (path.points.length < 2) {
+ path.unsupported = true;
+ }
+ path.closed = true;
+ target.closePath();
+ };
+ } else if (key === 'stroke') {
+ method = (...args) => this._stroke(target, path, args);
+ } else if (key === 'fillText') {
+ method = (...args) => this._fillText(target, args);
+ } else if (['translate', 'scale', 'rotate', 'transform', 'setTransform', 'resetTransform', 'restore'].includes(String(key))) {
+ method = (...args) => {
+ if (path.points.length) {
+ path.unsupported = true;
+ }
+ Reflect.apply(value, target, args);
+ };
+ } else if (['arc', 'arcTo', 'ellipse', 'rect', 'roundRect', 'bezierCurveTo', 'quadraticCurveTo'].includes(String(key))) {
+ method = (...args) => {
+ path.unsupported = true;
+ Reflect.apply(value, target, args);
+ };
+ }
+ methods.set(key, method);
+ return method;
+ },
+ set: (target, key, value) => Reflect.set(target, key, value, target),
+ });
+ this._contexts.set(native, proxy);
+ return proxy;
+ }
+
+ private _stroke(native: CanvasRenderingContext2D, path: IStrokePath, args: unknown[]): void {
+ const m = native.getTransform();
+ if (this._textClipBound || args.length || path.unsupported || path.points.length !== 2 || m.a !== m.d || m.a <= 0 || m.b || m.c
+ || native.shadowBlur || native.shadowOffsetX || native.shadowOffsetY
+ || !['rgba(0, 0, 0, 0)', 'transparent', '#00000000'].includes(native.shadowColor)
+ || (native.filter && native.filter !== 'none') || typeof native.strokeStyle !== 'string'
+ || !['source-over', 'destination-out'].includes(native.globalCompositeOperation)) {
+ Reflect.apply(native.stroke, native, args);
+ return;
+ }
+ const x0 = path.points[0][0] * m.a + m.e;
+ const y0 = path.points[0][1] * m.d + m.f;
+ const x1 = path.points[1][0] * m.a + m.e;
+ const y1 = path.points[1][1] * m.d + m.f;
+ const padding = Math.ceil(native.lineWidth * m.a / 2) + 2;
+ const left = Math.floor(Math.min(x0, x1)) - padding;
+ const top = Math.floor(Math.min(y0, y1)) - padding;
+ const width = Math.ceil(Math.max(x0, x1)) - left + padding;
+ const height = Math.ceil(Math.max(y0, y1)) - top + padding;
+ if (!Number.isFinite(width * height) || width * height > MAX_STROKE_PIXELS) {
+ native.stroke();
+ return;
+ }
+ const localX0 = x0 - left;
+ const localY0 = y0 - top;
+ const localX1 = x1 - left;
+ const localY1 = y1 - top;
+ const dash = native.getLineDash();
+ const key = JSON.stringify([
+ Math.round(localX0 * 1e6) / 1e6,
+ Math.round(localY0 * 1e6) / 1e6,
+ Math.round(localX1 * 1e6) / 1e6,
+ Math.round(localY1 * 1e6) / 1e6,
+ width,
+ height,
+ native.lineWidth * m.a,
+ native.strokeStyle,
+ native.lineCap,
+ native.lineJoin,
+ native.miterLimit,
+ dash.map((value) => value * m.a),
+ native.lineDashOffset * m.a,
+ path.closed,
+ ]);
+ let bitmap = this._bitmaps.get(key);
+ if (!bitmap) {
+ const canvas = createCanvasElement();
+ canvas.width = width;
+ canvas.height = height;
+ const paint = canvas.getContext('2d');
+ if (!paint) {
+ native.stroke();
+ return;
+ }
+ paint.setTransform(m.a, 0, 0, m.d, 0, 0);
+ paint.lineWidth = native.lineWidth;
+ paint.strokeStyle = native.strokeStyle;
+ paint.lineCap = native.lineCap;
+ paint.lineJoin = native.lineJoin;
+ paint.miterLimit = native.miterLimit;
+ paint.setLineDash(dash);
+ paint.lineDashOffset = native.lineDashOffset;
+ paint.beginPath();
+ paint.moveTo(localX0 / m.a, localY0 / m.d);
+ paint.lineTo(localX1 / m.a, localY1 / m.d);
+ if (path.closed) {
+ paint.closePath();
+ }
+ const halfWidth = native.lineWidth * m.a / 2;
+ const horizontal = localY0 === localY1 && localX0 !== localX1;
+ const vertical = localX0 === localX1 && localY0 !== localY1;
+ const center = horizontal ? localY0 : localX0;
+ const low = center - halfWidth;
+ const high = center + halfWidth;
+ // DOMMatrix's Float32 scale can slightly shift otherwise integral physical edges.
+ const lowPixel = Math.round(low);
+ const highPixel = Math.round(high);
+ if ((horizontal || vertical) && !dash.length && native.lineCap === 'butt'
+ && (!path.closed || native.lineJoin === 'miter')
+ && Math.abs(low - lowPixel) <= 1e-6 && Math.abs(high - highPixel) <= 1e-6 && highPixel > lowPixel) {
+ // Native software strokes can leave length-dependent gaps even on pixel-aligned straight lines.
+ paint.setTransform(1, 0, 0, 1, 0, 0);
+ paint.fillStyle = native.strokeStyle;
+ paint.fillRect(
+ horizontal ? Math.min(localX0, localX1) : lowPixel,
+ vertical ? Math.min(localY0, localY1) : lowPixel,
+ horizontal ? Math.abs(localX1 - localX0) : highPixel - lowPixel,
+ vertical ? Math.abs(localY1 - localY0) : highPixel - lowPixel
+ );
+ } else {
+ paint.stroke();
+ }
+ bitmap = { canvas, pixels: width * height };
+ this._trim(bitmap.pixels);
+ this._bitmaps.set(key, bitmap);
+ this._pixels += bitmap.pixels;
+ }
+ const smoothing = native.imageSmoothingEnabled;
+ native.setTransform(1, 0, 0, 1, 0, 0);
+ native.imageSmoothingEnabled = false;
+ try {
+ native.drawImage(bitmap.canvas, left, top);
+ } finally {
+ native.setTransform(m.a, m.b, m.c, m.d, m.e, m.f);
+ native.imageSmoothingEnabled = smoothing;
+ }
+ }
+
+ private _fillText(native: CanvasRenderingContext2D, args: unknown[]): void {
+ const m = native.getTransform();
+ const fallback = () => Reflect.apply(native.fillText, native, args);
+ if (args.length !== 3 || typeof args[0] !== 'string' || m.a !== m.d || m.a <= 0 || m.b || m.c
+ || native.shadowBlur || native.shadowOffsetX || native.shadowOffsetY
+ || !['rgba(0, 0, 0, 0)', 'transparent', '#00000000'].includes(native.shadowColor)
+ || (native.filter && native.filter !== 'none') || typeof native.fillStyle !== 'string'
+ || native.globalCompositeOperation !== 'source-over' || !document.fonts
+ || native.canvas.ownerDocument !== document
+ || !['ltr', 'rtl', 'inherit'].includes(native.direction)
+ || document.fonts.status === 'loading') {
+ fallback();
+ return;
+ }
+ if (!this._fonts) {
+ const fonts = document.fonts;
+ this._fonts = fonts;
+ const clear = () => this.clear();
+ fonts.addEventListener('loadingdone', clear);
+ fonts.addEventListener('loadingerror', clear);
+ this.disposeWithMe({ dispose: () => {
+ fonts.removeEventListener('loadingdone', clear);
+ fonts.removeEventListener('loadingerror', clear);
+ } });
+ }
+ if (this._fontRevision !== FontCache.metricsRevision) {
+ this.clear();
+ this._fontRevision = FontCache.metricsRevision;
+ }
+ const text = args[0];
+ const px = (args[1] as number) * m.a + m.e;
+ const py = (args[2] as number) * m.d + m.f;
+ const ix = Math.floor(px);
+ const iy = Math.floor(py);
+ let metrics: TextMetrics | undefined;
+ if (this._textClipBound) {
+ metrics = native.measureText(text);
+ const left = px - metrics.actualBoundingBoxLeft * m.a;
+ const right = px + metrics.actualBoundingBoxRight * m.a;
+ const top = py - metrics.actualBoundingBoxAscent * m.d;
+ const bottom = py + metrics.actualBoundingBoxDescent * m.d;
+ const clip = this._textClipBound;
+ // Keep native rasterization unless its bounds cull a still-visible antialiased edge.
+ if ((right > clip.left && left < clip.right && bottom > clip.top && top < clip.bottom)
+ || right < clip.left - 2 || left > clip.right + 2 || bottom < clip.top - 2 || top > clip.bottom + 2) {
+ fallback();
+ return;
+ }
+ }
+ const values = TEXT_PROPERTIES.map((property) => Reflect.get(native, property));
+ const language = native.canvas.closest('[lang]')?.getAttribute('lang') ?? document.documentElement.lang;
+ if (native.direction === 'inherit' && !['ltr', 'rtl'].includes(native.canvas.dir)) {
+ fallback();
+ return;
+ }
+ const direction = native.direction === 'inherit' ? (native.canvas.dir as 'ltr' | 'rtl') : native.direction;
+ if (this._textClipBound) {
+ metrics ??= native.measureText(text);
+ const left = Math.max(0, Math.floor(px - metrics.actualBoundingBoxLeft * m.a) - 2);
+ const top = Math.max(0, Math.floor(py - metrics.actualBoundingBoxAscent * m.d) - 2);
+ const width = Math.min(native.canvas.width, Math.ceil(px + metrics.actualBoundingBoxRight * m.a) + 2) - left;
+ const height = Math.min(native.canvas.height, Math.ceil(py + metrics.actualBoundingBoxDescent * m.d) + 2) - top;
+ if (!Number.isFinite(width * height) || width <= 0 || height <= 0 || width * height > MAX_STROKE_PIXELS) {
+ fallback();
+ return;
+ }
+ // A local glyph origin changes native Float32 antialiasing. Reuse one viewport-sized repair surface.
+ const canvas = this._textClipRepairCanvas ??= createCanvasElement();
+ if (canvas.width !== native.canvas.width || canvas.height !== native.canvas.height) {
+ canvas.width = native.canvas.width;
+ canvas.height = native.canvas.height;
+ }
+ canvas.dir = direction;
+ canvas.lang = language;
+ const paint = canvas.getContext('2d');
+ if (!paint) {
+ canvas.width = 0;
+ canvas.height = 0;
+ this._textClipRepairCanvas = undefined;
+ fallback();
+ return;
+ }
+ paint.setTransform(1, 0, 0, 1, 0, 0);
+ paint.clearRect(left, top, width, height);
+ TEXT_PROPERTIES.forEach((property, index) => {
+ if (values[index] !== undefined) {
+ Reflect.set(paint, property, values[index]);
+ }
+ });
+ paint.direction = direction;
+ paint.fillStyle = native.fillStyle;
+ paint.setTransform(m.a, m.b, m.c, m.d, m.e, m.f);
+ paint.fillText(text, args[1] as number, args[2] as number);
+ native.save();
+ try {
+ native.setTransform(1, 0, 0, 1, 0, 0);
+ native.imageSmoothingEnabled = false;
+ native.drawImage(canvas, left, top, width, height, left, top, width, height);
+ } finally {
+ native.restore();
+ }
+ return;
+ }
+ const key = JSON.stringify([
+ 'text',
+ text,
+ native.fillStyle,
+ m.a,
+ values,
+ direction,
+ language,
+ Math.round((px - ix) * 1e6) / 1e6,
+ Math.round((py - iy) * 1e6) / 1e6,
+ ]);
+ let bitmap = this._bitmaps.get(key);
+ if (!bitmap) {
+ metrics ??= native.measureText(text);
+ const left = Math.floor(px - metrics.actualBoundingBoxLeft * m.a) - 2;
+ const top = Math.floor(py - metrics.actualBoundingBoxAscent * m.d) - 2;
+ const width = Math.ceil(px + metrics.actualBoundingBoxRight * m.a) - left + 2;
+ const height = Math.ceil(py + metrics.actualBoundingBoxDescent * m.d) - top + 2;
+ if (!Number.isFinite(width * height) || width <= 0 || height <= 0 || width * height > MAX_STROKE_PIXELS) {
+ fallback();
+ return;
+ }
+ const canvas = createCanvasElement();
+ canvas.width = width;
+ canvas.height = height;
+ canvas.dir = direction;
+ canvas.lang = language;
+ const paint = canvas.getContext('2d');
+ if (!paint) {
+ fallback();
+ return;
+ }
+ TEXT_PROPERTIES.forEach((property, index) => {
+ if (values[index] !== undefined) {
+ Reflect.set(paint, property, values[index]);
+ }
+ });
+ paint.direction = direction;
+ paint.fillStyle = native.fillStyle;
+ paint.setTransform(m.a, 0, 0, m.d, px - left, py - top);
+ paint.fillText(text, 0, 0);
+ bitmap = { canvas, pixels: width * height, offsetX: left - ix, offsetY: top - iy };
+ this._trim(bitmap.pixels);
+ this._bitmaps.set(key, bitmap);
+ this._pixels += bitmap.pixels;
+ }
+ native.save();
+ try {
+ native.setTransform(1, 0, 0, 1, 0, 0);
+ native.imageSmoothingEnabled = false;
+ native.drawImage(bitmap.canvas, ix + bitmap.offsetX!, iy + bitmap.offsetY!);
+ } finally {
+ native.restore();
+ }
+ }
+
+ private _trim(incoming: number): void {
+ while (this._bitmaps.size >= this._maxEntries || this._pixels + incoming > MAX_PIXELS) {
+ const key = this._bitmaps.keys().next().value;
+ if (key === undefined) {
+ break;
+ }
+ const bitmap = this._bitmaps.get(key)!;
+ this._pixels -= bitmap.pixels;
+ bitmap.canvas.width = 0;
+ bitmap.canvas.height = 0;
+ this._bitmaps.delete(key);
+ }
+ }
+}
diff --git a/packages/engine-render/src/components/sheets/extensions/row-header-layout.ts b/packages/engine-render/src/components/sheets/extensions/row-header-layout.ts
index 42d2dea929..073f513900 100644
--- a/packages/engine-render/src/components/sheets/extensions/row-header-layout.ts
+++ b/packages/engine-render/src/components/sheets/extensions/row-header-layout.ts
@@ -49,6 +49,8 @@ const DEFAULT_PRINTING_ROW_STYLE = {
} as const;
export class RowHeaderLayout extends SheetExtension {
+ override readonly viewportCacheReusable = this.constructor === RowHeaderLayout;
+
override uKey = UNIQUE_KEY;
override Z_INDEX = 10;
// The workbook rows configuration and header style
diff --git a/packages/engine-render/src/components/sheets/interfaces.ts b/packages/engine-render/src/components/sheets/interfaces.ts
index c4a34a91f3..312aac7321 100644
--- a/packages/engine-render/src/components/sheets/interfaces.ts
+++ b/packages/engine-render/src/components/sheets/interfaces.ts
@@ -55,6 +55,7 @@ export interface IFontCacheItem {
displayText?: string;
resolvedHorizontalAlign?: HorizontalAlign;
textFitsCurrentCell?: boolean;
+ verticalInkOverflow?: number;
shrinkScale?: number;
}
diff --git a/packages/engine-render/src/components/sheets/row-header.ts b/packages/engine-render/src/components/sheets/row-header.ts
index 4279a0463c..dbbf0c8a19 100644
--- a/packages/engine-render/src/components/sheets/row-header.ts
+++ b/packages/engine-render/src/components/sheets/row-header.ts
@@ -47,6 +47,7 @@ export class SpreadsheetRowHeader extends SpreadsheetHeader {
constructor(oKey: string, spreadsheetSkeleton?: SpreadsheetSkeleton) {
super(oKey, spreadsheetSkeleton);
+ this.viewportCacheReusable = this.constructor === SpreadsheetRowHeader;
// this._initialProps(props);
this._initialDefaultExtension();
diff --git a/packages/engine-render/src/components/sheets/sheet-component.ts b/packages/engine-render/src/components/sheets/sheet-component.ts
index 3bcc09a0de..fd07010827 100644
--- a/packages/engine-render/src/components/sheets/sheet-component.ts
+++ b/packages/engine-render/src/components/sheets/sheet-component.ts
@@ -21,6 +21,7 @@ import type { SHEET_EXTENSION_TYPE } from './extensions/sheet-extension';
import type { SpreadsheetSkeleton } from './sheet.render-skeleton';
import { RENDER_CLASS_TYPE } from '../../basics/const';
import { RenderComponent } from '../component';
+import { FontCache } from '../docs/layout/shaping-engine/font-cache';
export abstract class SheetComponent extends RenderComponent<SpreadsheetSkeleton, SHEET_EXTENSION_TYPE, IRange[]> {
constructor(
@@ -30,6 +31,16 @@ export abstract class SheetComponent extends RenderComponent<SpreadsheetSkeleton
super(oKey);
}
+ protected _viewportCacheFontRevision = FontCache.metricsRevision;
+
+ override canReuseViewportCache(): boolean {
+ return this._viewportCacheFontRevision === FontCache.metricsRevision && super.canReuseViewportCache();
+ }
+
+ override onViewportCacheReuse(viewportInfo: IViewportInfo): void {
+ this._skeleton?.updateVisibleRange(viewportInfo);
+ }
+
getSkeleton() {
return this._skeleton;
}
@@ -40,6 +51,7 @@ export abstract class SheetComponent extends RenderComponent<SpreadsheetSkeleton
}
override render(mainCtx: UniverRenderingContext, bounds?: IViewportInfo) {
+ this._viewportCacheFontRevision = FontCache.metricsRevision;
if (!this.visible) {
this.makeDirty(false);
return this;
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 2f185483b2..f91cd085ee 100644
--- a/packages/engine-render/src/components/sheets/sheet.render-skeleton.ts
+++ b/packages/engine-render/src/components/sheets/sheet.render-skeleton.ts
@@ -55,6 +55,7 @@ import {
numfmt,
ObjectMatrix,
Range,
+ Rectangle,
searchArray,
SHEET_TEXT_LINE_GAP,
SheetSkeleton,
@@ -69,10 +70,11 @@ import type { ITransformChangeState } from '../../basics/interfaces';
import type { IBoundRectNoAngle, IPoint, IViewportInfo } from '../../basics/vector2';
import type { Scene } from '../../scene';
import type { IBorderCache, IFontCacheItem, IStylesCache } from './interfaces';
-import { BORDER_TYPE, COLOR_BLACK_RGB, MAXIMUM_COL_WIDTH, MAXIMUM_ROW_HEIGHT, MIN_COL_WIDTH } from '../../basics/const';
+import { BORDER_TYPE, COLOR_BLACK_RGB, FIX_ONE_PIXEL_BLUR_OFFSET, MAXIMUM_COL_WIDTH, MAXIMUM_ROW_HEIGHT, MIN_COL_WIDTH } from '../../basics/const';
import { getRotateOffsetAndFarthestHypotenuse } from '../../basics/draw';
import { convertTextRotation, VERTICAL_ROTATE_ANGLE } from '../../basics/text-rotation';
import { degToRad, getFontStyleString } from '../../basics/tools';
+import { Text } from '../../shape/text';
import { DocSimpleSkeleton } from '../docs/layout/doc-simple-skeleton';
import { DocumentSkeleton } from '../docs/layout/doc-skeleton';
import { FontCache } from '../docs/layout/shaping-engine/font-cache';
@@ -316,6 +318,8 @@ export class SpreadsheetSkeleton extends SheetSkeleton {
private _overflowCache: ObjectMatrix<IRange> = new ObjectMatrix();
private _incrementalFontRenderRanges: IRange[] = [];
+ private _preparedStyleRanges = new Map<string, { range: IRange; scaleY: number }>();
+ private _preparedMergeStyleRanges = new ObjectMatrix<IRange>();
private _stylesCache: IStylesCache = {
background: {},
backgroundPositions: new ObjectMatrix<ICellWithCoord>(),
@@ -327,6 +331,9 @@ export class SpreadsheetSkeleton extends SheetSkeleton {
/** A matrix to store if a (row, column) position has render cache. */
private _handleBgMatrix = new ObjectMatrix<boolean>();
private _handleBorderMatrix = new ObjectMatrix<boolean>();
+ private _emptyFontCache = new ObjectMatrix<boolean>();
+ private readonly _nativeTextClipCache = new ObjectMatrix<boolean>();
+ private readonly _plainTextVerticalOverflowByRow = new Map<number, number>();
private _showGridlines: BooleanNumber = BooleanNumber.TRUE;
private _gridlinesColor: string | undefined = undefined;
private _defaultGridlinesColor!: string;
@@ -346,6 +353,7 @@ export class SpreadsheetSkeleton extends SheetSkeleton {
this.textLineGap = _configService.getConfig<number>(SHEET_TEXT_LINE_GAP) ?? 0;
const themeService = _injector.get(ThemeService);
this.disposeWithMe(themeService.currentTheme$.subscribe(() => {
+ this._preparedMergeStyleRanges.reset();
const gray200 = themeService.getColorFromTheme('gray.200');
const gray900 = themeService.getColorFromTheme('gray.900');
this._defaultGridlinesColor = ColorKit.mix(gray200, gray900, 0.07).toHexString();
@@ -421,6 +429,26 @@ export class SpreadsheetSkeleton extends SheetSkeleton {
return this._incrementalFontRenderRanges;
}
+ get nativeTextClipCache(): ObjectMatrix<boolean> {
+ return this._nativeTextClipCache;
+ }
+
+ /** Bound source-row checks by the current cache, without scanning retained font entries. */
+ getPlainTextVerticalOverflow(bound?: IBoundRectNoAngle): number {
+ if (!this._plainTextVerticalOverflowByRow.size) return 0;
+ let overflow = 0;
+ if (bound) {
+ const { startRow, endRow } = this.getRangeByViewBound(bound);
+ for (let row = startRow; row <= endRow; row++) {
+ overflow = Math.max(overflow, this._plainTextVerticalOverflowByRow.get(row) ?? 0);
+ }
+ } else {
+ // Callers without a cache bound retain the conservative sparse-index fallback.
+ for (const value of this._plainTextVerticalOverflowByRow.values()) overflow = Math.max(overflow, value);
+ }
+ return overflow;
+ }
+
get showGridlines(): BooleanNumber {
return this._showGridlines;
}
@@ -450,13 +478,27 @@ export class SpreadsheetSkeleton extends SheetSkeleton {
};
this._handleBgMatrix.reset();
this._handleBorderMatrix.reset();
+ this._emptyFontCache.reset();
+ this._nativeTextClipCache.reset();
+ this._plainTextVerticalOverflowByRow.clear();
+ this._preparedStyleRanges.clear();
this._overflowCache.reset();
+ this._preparedMergeStyleRanges.reset();
}
setOverflowCache(value: ObjectMatrix<IRange>): void {
this._overflowCache = value;
}
+ private _refreshPlainTextVerticalOverflow(row: number): void {
+ let overflow = 0;
+ for (const font of Object.values(this._stylesCache.fontMatrix.getRow(row) ?? {})) {
+ overflow = Math.max(overflow, font?.verticalInkOverflow ?? 0);
+ }
+ if (overflow) this._plainTextVerticalOverflowByRow.set(row, overflow);
+ else this._plainTextVerticalOverflowByRow.delete(row);
+ }
+
getFont(rowIndex: number, columnIndex: number): Nullable<IFontCacheItem> {
const fontCache = this.stylesCache.fontMatrix;
if (!fontCache) {
@@ -508,6 +550,7 @@ export class SpreadsheetSkeleton extends SheetSkeleton {
}
this._clearTaskId = requestIdleCallback(() => {
+ const overflowRows = new Set<number>();
this._stylesCache.fontMatrix.forValue((row, col) => {
if (
row < (visibleStartRow - CACHE_COUNT) ||
@@ -516,8 +559,11 @@ export class SpreadsheetSkeleton extends SheetSkeleton {
col > (visibleEndColumn + CACHE_COUNT)
) {
this._stylesCache.fontMatrix.realDeleteValue(row, col);
+ this._nativeTextClipCache.realDeleteValue(row, col);
+ if (this._plainTextVerticalOverflowByRow.has(row)) overflowRows.add(row);
}
});
+ for (const row of overflowRows) this._refreshPlainTextVerticalOverflow(row);
this._clearTaskId = null;
});
@@ -542,18 +588,22 @@ export class SpreadsheetSkeleton extends SheetSkeleton {
!!vpInfo.diffX ||
!!vpInfo.diffY
);
+ const scaleY = options?.scaleY ?? 1;
+ const prepared = vpInfo && this._preparedStyleRanges.get(vpInfo.viewportKey);
+ const shouldUseIncrementalStyleRange = isIncrementalScroll && prepared?.scaleY === scaleY;
+ this._incrementalFontRenderRanges = [];
+ if (shouldUseIncrementalStyleRange && !vpInfo.shouldCacheUpdate
+ && Rectangle.contains(prepared.range, this.getRangeByViewport(vpInfo))) {
+ return this;
+ }
const hasMergeData = this.worksheet.getMergeData().length > 0;
- const shouldRefreshCacheForScroll = isIncrementalScroll && !!vpInfo.shouldCacheUpdate && !!vpInfo.diffX;
- const shouldUseIncrementalStyleRange = isIncrementalScroll && !shouldRefreshCacheForScroll;
const styleRanges = shouldUseIncrementalStyleRange
- ? (vpInfo.shouldCacheUpdate ? (vpInfo.diffCacheBounds?.map((bound) => this.getRangeByViewBound(bound)) ?? []) : [])
+ ? Rectangle.subtract(rowColumnSegment, prepared.range)
: [rowColumnSegment];
const visibleCellOptions: ISetStylesCacheForOneCellOptions = { cacheItem: { bg: true, border: true }, reuseExisting: isIncrementalScroll, hasMergeData, rowVisible: true };
const shortRowVisibleCellOptions: ISetStylesCacheForOneCellOptions = { ...visibleCellOptions, skipFontCache: true };
const overflowCellOptions: ISetStylesCacheForOneCellOptions = { cacheItem: { bg: false, border: false }, reuseExisting: isIncrementalScroll, hasMergeData, rowVisible: true };
- const scaleY = options?.scaleY ?? 1;
const hasRenderContext = options !== undefined;
- this._incrementalFontRenderRanges = [];
// clear cache out of visible range
// this._clearCacheOutOfVisibleRange(visibleStartRow, visibleEndRow, visibleStartColumn, visibleEndColumn);
@@ -653,6 +703,9 @@ export class SpreadsheetSkeleton extends SheetSkeleton {
}
}
+ if (vpInfo) {
+ this._preparedStyleRanges.set(vpInfo.viewportKey, { range: { ...rowColumnSegment }, scaleY });
+ }
return this;
}
@@ -1154,6 +1207,7 @@ export class SpreadsheetSkeleton extends SheetSkeleton {
const { documentSkeleton, vertexAngle = 0, centerAngle = 0, horizontalAlign, wrapStrategy } = docsConfig;
const cell = this._cellData.getValue(row, column);
const { t: cellValueType = CellValueType.STRING } = cell || {};
+ delete docsConfig.verticalInkOverflow;
let horizontalAlignPos = horizontalAlign;
/**
* #univer-pro/issues/334
@@ -1224,6 +1278,25 @@ export class SpreadsheetSkeleton extends SheetSkeleton {
if (contentSize.width < currentColumnWidth) {
docsConfig.textFitsCurrentCell = true;
+ if (!documentSkeleton && !vertexAngle && !centerAngle) {
+ const rowHeight = Math.max(0, this.rowHeightAccumulation[row] - (this.rowHeightAccumulation[row - 1] ?? 0)
+ - (this.gapConfig?.rowGaps?.[row]?.size ?? 0));
+ const padding = docsConfig.style?.pd ?? DEFAULT_PADDING_DATA;
+ const top = padding.t ?? DEFAULT_PADDING_DATA.t;
+ const bottom = padding.b ?? DEFAULT_PADDING_DATA.b;
+ const ink = Text.getPlainTextVerticalBounds({
+ text: docsConfig.displayText ?? getDisplayValueFromCell(docsConfig.cellData),
+ fontStyle: docsConfig.fontString,
+ height: rowHeight - top - bottom,
+ top: top + FIX_ONE_PIXEL_BLUR_OFFSET,
+ vAlign: docsConfig.verticalAlign,
+ });
+ const overflow = Math.max(0, -ink.top, ink.bottom - rowHeight);
+ if (Number.isFinite(overflow) && overflow > 0) {
+ docsConfig.verticalInkOverflow = overflow;
+ this._plainTextVerticalOverflowByRow.set(row, Math.max(this._plainTextVerticalOverflowByRow.get(row) ?? 0, overflow));
+ }
+ }
return true;
}
@@ -1372,6 +1445,8 @@ export class SpreadsheetSkeleton extends SheetSkeleton {
* Any changes to sheet model would reset cache.
*/
_resetCache(): void {
+ this._preparedStyleRanges.clear();
+ this._preparedMergeStyleRanges.reset();
this._stylesCache = {
background: {},
backgroundPositions: new ObjectMatrix<ICellWithCoord>(),
@@ -1381,23 +1456,36 @@ export class SpreadsheetSkeleton extends SheetSkeleton {
this._handleBgMatrix?.reset();
this._handleBorderMatrix?.reset();
+ this._emptyFontCache?.reset();
+ this._nativeTextClipCache.reset();
+ this._plainTextVerticalOverflowByRow.clear();
this._overflowCache?.reset();
}
override resetRangeCache(ranges: IRange[]): void {
+ const overflowRows = this._plainTextVerticalOverflowByRow.size ? new Set<number>() : null;
+ this._preparedStyleRanges.clear();
+ // An edited member can change any of a merged anchor's four prepared edges.
+ this._preparedMergeStyleRanges.reset();
for (let i = 0; i < ranges.length; i++) {
const range = ranges[i];
Range.foreach(range, (row, col) => {
+ if (this._plainTextVerticalOverflowByRow.has(row)) overflowRows?.add(row);
this._stylesCache.fontMatrix.realDeleteValue(row, col);
+ this._nativeTextClipCache.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);
+ this._emptyFontCache.realDeleteValue(row, col);
Object.values(this._stylesCache.background ?? {}).forEach((backgroundMatrix) => {
backgroundMatrix.realDeleteValue(row, col);
});
});
}
+ if (overflowRows) {
+ for (const row of overflowRows) this._refreshPlainTextVerticalOverflow(row);
+ }
this.makeDirty(true);
}
@@ -1527,7 +1615,11 @@ export class SpreadsheetSkeleton extends SheetSkeleton {
}
_setFontStylesCache(row: number, col: number, cellData: Nullable<ICellDataForSheetInterceptor>, style: IStyleData, hasMergeData = true) {
- if (isNullCell(cellData)) return;
+ if (isNullCell(cellData)) {
+ this._emptyFontCache.setValue(row, col, true);
+ return;
+ }
+ this._emptyFontCache.realDeleteValue(row, col);
let config: Partial<IFontCacheItem> = {
cellData,
@@ -1607,6 +1699,10 @@ export class SpreadsheetSkeleton extends SheetSkeleton {
this._applyShrinkToFit(row, col, fontCacheItem, style);
this._calculateOverflowCell(row, col, fontCacheItem, hasMergeData);
this._stylesCache.fontMatrix.setValue(row, col, fontCacheItem);
+ if (fontCacheItem.vertexAngle || fontCacheItem.centerAngle
+ || (fontCacheItem.shrinkScale !== undefined && fontCacheItem.shrinkScale !== 1)) {
+ this._nativeTextClipCache.setValue(row, col, true);
+ }
}
/**
@@ -1633,11 +1729,14 @@ export class SpreadsheetSkeleton extends SheetSkeleton {
options = { cacheItem: { bg: true, border: true } };
}
- const cacheItem = options.cacheItem;
- if (options.reuseExisting && cacheItem && !options.mergeRange) {
+ const cacheItem = options.cacheItem ?? { bg: true, border: true };
+ const mergeRange = options.mergeRange;
+ const preparedMergeRange = mergeRange && this._preparedMergeStyleRanges.getValue(row, col);
+ if (options.reuseExisting && (!mergeRange || (preparedMergeRange && Rectangle.equals(preparedMergeRange, 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 && (options.skipFontCache || this._stylesCache.fontMatrix.getValue(row, col))) {
+ if (bgHandled && borderHandled
+ && (options.skipFontCache || this._stylesCache.fontMatrix.getValue(row, col) || this._emptyFontCache.getValue(row, col))) {
return;
}
}
@@ -1667,13 +1766,19 @@ export class SpreadsheetSkeleton extends SheetSkeleton {
const cell = this.worksheet.getCell(row, col) || this.worksheet.getCellRaw(row, col);
const style = this.worksheet.getComposedCellStyleByCellData(row, col, cell);
- if (!cell && Object.keys(style).length === 0) return;
+ // Empty merge anchors still own borders contributed by other members.
+ if (!mergeRange && isNullCell(cell) && Object.keys(style).length === 0) {
+ return;
+ }
this._setBgStylesCache(row, col, style, options);
this._setBorderStylesCache(row, col, style, options);
if (!options.skipFontCache) {
this._setFontStylesCache(row, col, { ...cell, s: style }, style, options.hasMergeData ?? true);
}
+ if (mergeRange && cacheItem.bg && cacheItem.border && !options.skipFontCache) {
+ this._preparedMergeStyleRanges.setValue(row, col, { ...mergeRange });
+ }
}
/**
diff --git a/packages/engine-render/src/components/sheets/spreadsheet.ts b/packages/engine-render/src/components/sheets/spreadsheet.ts
index da1a1cf413..06c2fea664 100644
--- a/packages/engine-render/src/components/sheets/spreadsheet.ts
+++ b/packages/engine-render/src/components/sheets/spreadsheet.ts
@@ -15,6 +15,7 @@
*/
import type { IPosition, IRange, Nullable } from '@univerjs/core';
+import { BooleanNumber, sortRules, Tools } from '@univerjs/core';
import type { IBoundRectNoAngle, IViewportInfo, Vector2 } from '../../basics/vector2';
import type { UniverRenderingContext2D } from '../../context';
import type { Engine } from '../../engine';
@@ -24,20 +25,25 @@ import type { IDrawInfo } from '../extension';
import type { Background } from './extensions/background';
import type { Border } from './extensions/border';
import type { Font } from './extensions/font';
-import type { IPaintForRefresh, IPaintForScrolling, SHEET_VIEWPORT_KEY } from './interfaces';
+import type { IPaintForRefresh, IPaintForScrolling } from './interfaces';
import type { SpreadsheetSkeleton } from './sheet.render-skeleton';
-import { BooleanNumber, sortRules, Tools } from '@univerjs/core';
-import { FIX_ONE_PIXEL_BLUR_OFFSET, RENDER_CLASS_TYPE } from '../../basics/const';
+import { BORDER_TYPE, FIX_ONE_PIXEL_BLUR_OFFSET, RENDER_CLASS_TYPE } from '../../basics/const';
import { getColor } from '../../basics/tools';
import { Canvas } from '../../canvas';
import { Documents } from '../docs/document';
+import { FontCache } from '../docs/layout/shaping-engine/font-cache';
import { SpreadsheetExtensionRegistry } from '../extension';
import { sheetContentViewportKeys, sheetHeaderViewportKeys } from './constants';
+import { RenderPrimitiveCache } from './extensions/render-primitive-cache';
import { SHEET_EXTENSION_PREFIX, SHEET_EXTENSION_TYPE } from './extensions/sheet-extension';
+import { SHEET_VIEWPORT_KEY } from './interfaces';
import { SheetComponent } from './sheet-component';
const OBJECT_KEY = '__SHEET_EXTENSION_FONT_DOCUMENT_INSTANCE__';
const MERGE_REPAIR_CACHE_REFRESH_RATIO = 0.6;
+const SCROLL_REPAIR_INK_HALO = 2;
+const BORDER_INK_HALO = 2;
+const BORDER_EDGE_KEYS = new Set<string>([BORDER_TYPE.TOP, BORDER_TYPE.BOTTOM, BORDER_TYPE.LEFT, BORDER_TYPE.RIGHT]);
const CUSTOM_EXTENSION_KEY = 'DefaultCustomExtension';
const MARKER_EXTENSION_KEY = 'DefaultMarkerExtension';
const RANGE_PROTECTION_VIEW_EXTENSION_KEY = 'RANGE_PROTECTION_CAN_VIEW_RENDER_EXTENSION_KEY';
@@ -47,6 +53,23 @@ const PRINTING_GRIDLINES_COLOR = getColor([214, 216, 219]);
interface IRepaintBound {
bound: IBoundRectNoAngle;
repairsMerge: boolean;
+ repairsNativeText?: boolean;
+}
+
+interface IScrollCacheState {
+ canvas: Canvas;
+ width: number;
+ height: number;
+ pixelRatio: number;
+ scaleX: number;
+ scaleY: number;
+ left: number;
+ top: number;
+ axisAligned: boolean;
+ viewportLeft: number;
+ viewportTop: number;
+ viewportRight: number;
+ viewportBottom: number;
}
interface ISparseExtensionFeatureFlags {
@@ -73,7 +96,11 @@ function pushSparseCellRange(ranges: IRange[], row: number, col: number) {
});
}
-function scanSparseExtensionFeatures(spreadsheetSkeleton: SpreadsheetSkeleton, ranges: IRange[]): ISparseExtensionFeatureFlags | null {
+function scanSparseExtensionFeatures(
+ spreadsheetSkeleton: SpreadsheetSkeleton,
+ ranges: IRange[],
+ includeMergedAnchors: boolean
+): ISparseExtensionFeatureFlags | null {
const { worksheet } = spreadsheetSkeleton;
if (!worksheet || !ranges.length) {
return null;
@@ -87,45 +114,63 @@ function scanSparseExtensionFeatures(spreadsheetSkeleton: SpreadsheetSkeleton, r
selectionProtectionRanges: [],
};
+ const visitCell = (row: number, col: number, renderRow = row, renderCol = col) => {
+ 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 typeof cachedCell);
+ if (!cell) {
+ return;
+ }
+ if (cell.customRender?.length) {
+ flags.hasCustomRender = true;
+ pushSparseCellRange(flags.customRenderRanges, renderRow, renderCol);
+ }
+ if (cell.markers) {
+ flags.hasMarkers = true;
+ pushSparseCellRange(flags.markerRanges, renderRow, renderCol);
+ }
+ if (cell.selectionProtection?.length) {
+ flags.hasSelectionProtection = true;
+ pushSparseCellRange(flags.selectionProtectionRanges, renderRow, renderCol);
+ }
+ };
+
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);
+ if (worksheet.getColVisible(col)) {
+ visitCell(row, col);
}
}
}
+ if (!includeMergedAnchors) {
+ continue;
+ }
+ for (const merge of worksheet.getMergedCellRange(range.startRow, range.startColumn, range.endRow, range.endColumn)) {
+ if (merge.startRow >= range.startRow && merge.startColumn >= range.startColumn
+ && worksheet.getRowVisible(merge.startRow) && worksheet.getColVisible(merge.startColumn)) {
+ continue;
+ }
+ let row = Math.max(range.startRow, merge.startRow);
+ let col = Math.max(range.startColumn, merge.startColumn);
+ const endRow = Math.min(range.endRow, merge.endRow);
+ const endColumn = Math.min(range.endColumn, merge.endColumn);
+ while (row <= endRow && !worksheet.getRowVisible(row)) {
+ row++;
+ }
+ while (col <= endColumn && !worksheet.getColVisible(col)) {
+ col++;
+ }
+ if (row <= endRow && col <= endColumn) {
+ visitCell(merge.startRow, merge.startColumn, row, col);
+ }
+ }
}
return flags;
@@ -196,6 +241,44 @@ function boundsOverlap(a: IBoundRectNoAngle, b: IBoundRectNoAngle) {
return a.left <= b.right && a.right >= b.left && a.top <= b.bottom && a.bottom >= b.top;
}
+function getIntersectBound(a: IBoundRectNoAngle, b: IBoundRectNoAngle): Nullable<IBoundRectNoAngle> {
+ const left = Math.max(a.left, b.left);
+ const right = Math.min(a.right, b.right);
+ const top = Math.max(a.top, b.top);
+ const bottom = Math.min(a.bottom, b.bottom);
+ return right > left && bottom > top ? { left, right, top, bottom } : null;
+}
+
+function getOutwardRoundedBound(bound: IBoundRectNoAngle): IBoundRectNoAngle {
+ return {
+ left: Math.floor(bound.left),
+ top: Math.floor(bound.top),
+ right: Math.ceil(bound.right),
+ bottom: Math.ceil(bound.bottom),
+ };
+}
+
+function appendRepaintBound(bounds: IRepaintBound[], next: IRepaintBound) {
+ for (let index = 0; index < bounds.length;) {
+ const previous = bounds[index];
+ if (!getIntersectBound(next.bound, previous.bound)) {
+ index++;
+ continue;
+ }
+ next.bound = {
+ left: Math.min(next.bound.left, previous.bound.left),
+ top: Math.min(next.bound.top, previous.bound.top),
+ right: Math.max(next.bound.right, previous.bound.right),
+ bottom: Math.max(next.bound.bottom, previous.bound.bottom),
+ };
+ next.repairsMerge ||= previous.repairsMerge;
+ next.repairsNativeText ||= previous.repairsNativeText;
+ bounds.splice(index, 1);
+ index = 0;
+ }
+ bounds.push(next);
+}
+
function getClippedBoundArea(bound: IBoundRectNoAngle, clipBound: IBoundRectNoAngle) {
const width = Math.max(0, Math.min(bound.right, clipBound.right) - Math.max(bound.left, clipBound.left));
const height = Math.max(0, Math.min(bound.bottom, clipBound.bottom) - Math.max(bound.top, clipBound.top));
@@ -266,7 +349,17 @@ function clipBlitRectToBounds(rect: IBlitRect, sourceWidth: number, sourceHeight
}
export class Spreadsheet extends SheetComponent {
+ override viewportCacheReusable = this.constructor === Spreadsheet;
+
+ override onViewportCacheReuse(viewportInfo: IViewportInfo): void {
+ if (!sheetHeaderViewportKeys.includes(viewportInfo.viewportKey as SHEET_VIEWPORT_KEY)) {
+ super.onViewportCacheReuse(viewportInfo);
+ }
+ }
+
private _scrollBufferCanvases = new Map<string, Canvas>();
+ private _scrollCacheStates = new Map<string, IScrollCacheState | null>();
+ private readonly _gridlineCache = new RenderPrimitiveCache();
private _backgroundExtension!: Background;
private _borderExtension!: Border;
@@ -292,6 +385,7 @@ export class Spreadsheet extends SheetComponent {
private _allowCache: boolean = true
) {
super(oKey, spreadsheetSkeleton);
+ this.disposeWithMe(this._gridlineCache);
this._initialDefaultExtension();
this.makeDirty(true);
}
@@ -325,6 +419,7 @@ export class Spreadsheet extends SheetComponent {
this._documents?.dispose();
this._scrollBufferCanvases.forEach((canvas) => canvas.dispose());
this._scrollBufferCanvases.clear();
+ this._scrollCacheStates.clear();
// TODO: fix memory leak without reassigning these properties
this._documents = null as unknown as Documents;
@@ -338,7 +433,7 @@ export class Spreadsheet extends SheetComponent {
* @param ctx
* @param viewportInfo
*/
- override draw(ctx: UniverRenderingContext2D, viewportInfo: IViewportInfo, isMergeRepair = false) {
+ override draw(ctx: UniverRenderingContext2D, viewportInfo: IViewportInfo, isMergeRepair = false, textClipBound?: IBoundRectNoAngle) {
const spreadsheetSkeleton = this.getSkeleton();
if (!spreadsheetSkeleton) {
return;
@@ -347,7 +442,7 @@ export class Spreadsheet extends SheetComponent {
const parentScale = this.getParentScale();
const diffRanges = this._refreshIncrementalState && viewportInfo.diffBounds
- ? viewportInfo.diffBounds?.map((bound) => spreadsheetSkeleton.getRangeByViewBound(bound))
+ ? viewportInfo.diffBounds?.map((bound) => spreadsheetSkeleton.getRangeByViewBound(getOutwardRoundedBound(bound)))
: [];
const cacheRange = spreadsheetSkeleton.getCacheRangeByViewport(viewportInfo, this.isPrinting);
@@ -361,11 +456,14 @@ export class Spreadsheet extends SheetComponent {
endColumn: cacheRange.endColumn,
}))
: viewRanges;
+ const borderViewRanges = this._refreshIncrementalState && diffRanges.length > 0
+ ? this._getBorderRenderRanges(spreadsheetSkeleton, viewportInfo, overflowSafeViewRanges, hasMergeData, cacheRange)
+ : viewRanges;
const extensions = this.getExtensionsByOrder();
const backgroundExtensions = extensions.filter((extension) => extension.type === SHEET_EXTENSION_TYPE.BACKGROUND);
const gridExtensions = extensions.filter((extension) => extension.type !== SHEET_EXTENSION_TYPE.BACKGROUND);
- const sparseExtensionFeatures = !isMergeRepair && hasSparseExtension(gridExtensions)
- ? scanSparseExtensionFeatures(spreadsheetSkeleton, viewRanges)
+ const sparseExtensionFeatures = hasSparseExtension(gridExtensions)
+ ? scanSparseExtensionFeatures(spreadsheetSkeleton, viewRanges, isMergeRepair)
: null;
// At this moment, ctx.transform is at topLeft of sheet content, cell(0, 0)
@@ -388,8 +486,13 @@ export class Spreadsheet extends SheetComponent {
};
drawBackgroundExtensions(diffRanges, viewRanges);
- this._drawAuxiliary(ctx, hasMergeData, (clearedRanges) => {
- drawBackgroundExtensions(clearedRanges, clearedRanges);
+ // Overwrite opaque interiors only inside the offscreen cache's integer device clip.
+ const repairNativeGridlines = !!ctx._context && ctx.__mode !== 'printing' && ctx.getSystemType() === 'Linux'
+ && this.allowCache && ctx._context.canvas === (scene?.getViewport(viewportInfo.viewportKey)?.canvas ?? viewportInfo.cacheCanvas)?.getCanvasEle();
+ this._gridlineCache.draw(ctx, () => {
+ this._drawAuxiliary(ctx, hasMergeData, (clearedRanges) => {
+ drawBackgroundExtensions(clearedRanges, clearedRanges);
+ }, repairNativeGridlines, textClipBound);
});
for (const extension of gridExtensions) {
@@ -397,10 +500,15 @@ export class Spreadsheet extends SheetComponent {
continue;
}
- const extensionViewRanges = extension === this._fontExtension || extension === this._borderExtension
- ? overflowSafeViewRanges
- : viewRanges;
- const extensionDiffRanges = getSparseExtensionDiffRanges(extension.uKey, sparseExtensionFeatures, diffRanges);
+ let extensionViewRanges = viewRanges;
+ if (extension === this._fontExtension) {
+ extensionViewRanges = overflowSafeViewRanges;
+ } else if (extension === this._borderExtension) {
+ extensionViewRanges = borderViewRanges;
+ }
+ const extensionDiffRanges = extension === this._borderExtension && diffRanges.length
+ ? borderViewRanges
+ : getSparseExtensionDiffRanges(extension.uKey, sparseExtensionFeatures, diffRanges);
const timeKey = `${SHEET_EXTENSION_PREFIX}${extension.uKey}`;
const st = Tools.now();
extension.draw(ctx, parentScale, spreadsheetSkeleton, extensionDiffRanges, {
@@ -410,12 +518,51 @@ export class Spreadsheet extends SheetComponent {
viewportKey: viewportInfo.viewportKey,
viewBound: viewportInfo.cacheBound,
diffBounds: viewportInfo.diffBounds,
+ textClipBound,
} as IDrawInfo);
const cost = Tools.now() - st;
this.addRenderFrameTimeMetricToScene(timeKey, cost, scene);
}
}
+ private _getBorderRenderRanges(
+ skeleton: SpreadsheetSkeleton,
+ viewportInfo: IViewportInfo,
+ overflowSafeRanges: IRange[],
+ hasMergeData: boolean,
+ cacheRange: IRange
+ ): IRange[] {
+ if (this.isPrinting) {
+ return overflowSafeRanges;
+ }
+ // Three-unit thick borders and double edges can reach beyond their owning cell.
+ const ranges = viewportInfo.diffBounds!.map((bound) => skeleton.getRangeByViewBound(getOutwardRoundedBound({
+ left: bound.left - BORDER_INK_HALO,
+ top: bound.top - BORDER_INK_HALO,
+ right: bound.right + BORDER_INK_HALO,
+ bottom: bound.bottom + BORDER_INK_HALO,
+ })));
+ if (hasMergeData) {
+ for (const range of ranges) {
+ const merges = skeleton.worksheet.getMergedCellRange(range.startRow, range.startColumn, range.endRow, range.endColumn);
+ for (const merge of merges) {
+ const border = skeleton.stylesCache.border?.getValue(merge.startRow, merge.startColumn);
+ if (border && Object.keys(border).some((key) => !BORDER_EDGE_KEYS.has(key))) {
+ // Preserve the existing full-row path for diagonals owned by an offscreen anchor.
+ return overflowSafeRanges;
+ }
+ }
+ }
+ }
+ // Keep halo owners within the full paint's range so frozen edges cannot gain extra strokes.
+ return ranges.map((range) => ({
+ startRow: Math.max(range.startRow, cacheRange.startRow),
+ endRow: Math.min(range.endRow, cacheRange.endRow),
+ startColumn: Math.max(range.startColumn, cacheRange.startColumn),
+ endColumn: Math.min(range.endColumn, cacheRange.endColumn),
+ })).filter((range) => range.startRow <= range.endRow && range.startColumn <= range.endColumn);
+ }
+
addRenderFrameTimeMetricToScene(timeKey: string, val: number, scene: Scene) {
scene = scene ?? this.getScene();
// scene?.addRenderFrameTimeMetric(timeKey, val);
@@ -476,7 +623,7 @@ export class Spreadsheet extends SheetComponent {
};
}
- isForceDirty(): boolean {
+ override isForceDirty(): boolean {
return this._forceDirty;
}
@@ -514,7 +661,42 @@ export class Spreadsheet extends SheetComponent {
this._dirtyBounds = dirtyBounds;
}
- renderByViewports(mainCtx: UniverRenderingContext2D, viewportInfo: IViewportInfo, spreadsheetSkeleton: SpreadsheetSkeleton) {
+ renderByViewports(mainCtx: UniverRenderingContext2D, inputViewportInfo: IViewportInfo, spreadsheetSkeleton: SpreadsheetSkeleton) {
+ let viewportInfo = inputViewportInfo;
+ if (viewportInfo.viewportKey === SHEET_VIEWPORT_KEY.VIEW_MAIN_LEFT_TOP && mainCtx.__mode !== 'printing'
+ && mainCtx._context && mainCtx.getSystemType() === 'Linux' && mainCtx.getBrowserType() === 'Safari'
+ && this._hasFractionalViewportPixels(viewportInfo)) {
+ // WebKit varies fractional frozen-corner bitmap coverage; invalidate the bitmap and use native extension draws.
+ this._scrollCacheStates.set(viewportInfo.viewportKey, null);
+ this.draw(mainCtx, viewportInfo);
+ return;
+ }
+ const cacheState = this._getScrollCacheState(mainCtx, viewportInfo);
+ const previousState = this._getReusableScrollCacheState(mainCtx, viewportInfo);
+ if (previousState) {
+ const diffX = (cacheState.left - previousState.left) / cacheState.scaleX;
+ const diffY = (cacheState.top - previousState.top) / cacheState.scaleY;
+ const { viewBound } = viewportInfo;
+ const diffBounds = [...viewportInfo.diffBounds];
+ if (!diffBounds.length) {
+ if (diffX) {
+ const left = diffX < 0 ? viewBound.right + diffX : viewBound.left;
+ diffBounds.push({ ...viewBound, left, right: left + Math.abs(diffX) });
+ }
+ if (diffY) {
+ const top = diffY < 0 ? viewBound.bottom + diffY : viewBound.top;
+ diffBounds.push({ ...viewBound, top, bottom: top + Math.abs(diffY) });
+ }
+ }
+ // View bounds and bitmap origins can round opposite sides of a half pixel.
+ const expand = (bound: IBoundRectNoAngle) => ({
+ left: bound.left - 1 / cacheState.scaleX,
+ right: bound.right + 1 / cacheState.scaleX,
+ top: bound.top - 1 / cacheState.scaleY,
+ bottom: bound.bottom + 1 / cacheState.scaleY,
+ });
+ viewportInfo = { ...viewportInfo, diffX, diffY, diffBounds: diffBounds.map(expand), diffCacheBounds: viewportInfo.diffCacheBounds.map(expand) };
+ }
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();
@@ -534,9 +716,19 @@ export class Spreadsheet extends SheetComponent {
const hasMergeData = spreadsheetSkeleton.worksheet.getMergeData().length > 0;
const isScrolling = diffX !== 0 || diffY !== 0;
const mergeRepairBounds = this._getMergeRepairBounds(spreadsheetSkeleton, viewportInfo, hasMergeData, isScrolling);
- const repaintBounds = this._getRepaintBounds(viewportInfo, mergeRepairBounds);
+ const repaintBounds = this._getRepaintBounds(viewportInfo, mergeRepairBounds, mainCtx);
const shouldRefreshForMergeRepairArea = exceedsMergeRepairThreshold(viewportInfo.cacheBound, repaintBounds, mergeRepairBounds.length > 0);
- const shouldRefreshCache = isDirty || isForceDirty || isScrollJumpOutsideCache || shouldRefreshForMergeRepairArea || (shouldCacheUpdate && diffX !== 0);
+ const shouldRefreshForHorizontalResampling = this._requiresHorizontalResampling(mainCtx, viewportInfo);
+ // Fractional frozen-column clipping changes translucent edge coverage after a vertical cache copy.
+ const shouldRefreshForFrozenEdge = (viewportInfo.viewportKey === SHEET_VIEWPORT_KEY.VIEW_MAIN_LEFT
+ && diffY !== 0 && this._hasFractionalViewportPixels(viewportInfo))
+ || this._requiresNativeFrozenEdgeRepaint(mainCtx, viewportInfo, repaintBounds);
+ const shouldRefreshForNativeGridlines = isScrolling && this._requiresNativeGridlineRepaint(mainCtx, spreadsheetSkeleton, viewportInfo, hasMergeData);
+ const shouldRefreshForGapStripes = isScrolling && this._requiresGapStripeRepaint(spreadsheetSkeleton, viewportInfo);
+ const incompatibleCache = this._scrollCacheStates.has(viewportInfo.viewportKey) && !previousState;
+ const shouldRefreshCache = isDirty || isForceDirty || incompatibleCache || isScrollJumpOutsideCache || shouldRefreshForMergeRepairArea
+ || shouldRefreshForHorizontalResampling || shouldRefreshForFrozenEdge || shouldRefreshForNativeGridlines || shouldRefreshForGapStripes ||
+ (shouldCacheUpdate && diffX !== 0 && !this._canPaintHorizontalScrollIncrementally(mainCtx, viewportInfo));
if (diffBounds.length === 0 || (diffX === 0 && diffY === 0) || shouldRefreshCache) {
if (shouldRefreshCache) {
this.addRenderTagToScene('scrolling', false);
@@ -557,7 +749,7 @@ export class Spreadsheet extends SheetComponent {
scaleY,
columnHeaderHeightAndMarginTop,
rowHeaderWidthAndMarginLeft,
- }, mergeRepairBounds);
+ }, mergeRepairBounds, repaintBounds);
cacheCtx.restore();
cacheCtx = renderCacheCanvas.getContext();
cacheCtx.save();
@@ -570,6 +762,7 @@ export class Spreadsheet extends SheetComponent {
const dh = bottom - top + columnHeaderHeightAndMarginTop;
this._applyCache(renderCacheCanvas, mainCtx, sourceLeft, sourceTop, dw, dh, left, top, dw, dh);
cacheCtx.restore();
+ this._scrollCacheStates.set(viewportInfo.viewportKey, { ...cacheState, canvas: renderCacheCanvas });
}
private _getMergeRepairBounds(spreadsheetSkeleton: SpreadsheetSkeleton, viewportInfo: IViewportInfo, hasMergeData: boolean, isScrolling: boolean) {
@@ -583,7 +776,7 @@ export class Spreadsheet extends SheetComponent {
const visited = new Set<string>();
for (const dirtyBound of dirtyBounds) {
- const range = spreadsheetSkeleton.getRangeByViewBound(dirtyBound);
+ const range = spreadsheetSkeleton.getRangeByViewBound(getOutwardRoundedBound(dirtyBound));
const mergeRanges = spreadsheetSkeleton.worksheet.getMergedCellRange(range.startRow, range.startColumn, range.endRow, range.endColumn);
for (const mergeRange of mergeRanges) {
const key = `${mergeRange.startRow}:${mergeRange.startColumn}`;
@@ -604,57 +797,320 @@ export class Spreadsheet extends SheetComponent {
return mergeBounds;
}
- private _getRepaintBounds(viewportInfo: IViewportInfo, mergeRepairBounds: IBoundRectNoAngle[]): IRepaintBound[] {
- const repaintBounds: IRepaintBound[] = viewportInfo.shouldCacheUpdate
- ? viewportInfo.diffCacheBounds.map((bound) => ({ bound: { ...bound }, repairsMerge: false }))
- : [];
- for (const mergeRepairBound of mergeRepairBounds) {
- const overlappingBound = repaintBounds.find(({ bound }) => boundsOverlap(bound, mergeRepairBound));
- if (overlappingBound) {
- overlappingBound.bound.left = Math.min(overlappingBound.bound.left, mergeRepairBound.left);
- overlappingBound.bound.top = Math.min(overlappingBound.bound.top, mergeRepairBound.top);
- overlappingBound.bound.right = Math.max(overlappingBound.bound.right, mergeRepairBound.right);
- overlappingBound.bound.bottom = Math.max(overlappingBound.bound.bottom, mergeRepairBound.bottom);
- overlappingBound.repairsMerge = true;
+ private _getRepaintBounds(
+ viewportInfo: IViewportInfo,
+ mergeRepairBounds: IBoundRectNoAngle[],
+ mainCtx: UniverRenderingContext2D
+ ): IRepaintBound[] {
+ const transform = mainCtx.getTransform();
+ if (!this._getReusableScrollCacheState(mainCtx, viewportInfo) && mergeRepairBounds.length && (!Number.isInteger(viewportInfo.diffX * transform.a)
+ || !Number.isInteger(viewportInfo.diffY * transform.d))) {
+ // Fractional bitmap shifts resample text. Rebuild the full merge to preserve its rasterization.
+ const repaintBounds: IRepaintBound[] = viewportInfo.shouldCacheUpdate
+ ? viewportInfo.diffCacheBounds.map((bound) => ({ bound: { ...bound }, repairsMerge: false }))
+ : [];
+ for (const mergeBound of mergeRepairBounds) {
+ const overlapping = repaintBounds.find(({ bound }) => boundsOverlap(bound, mergeBound));
+ if (overlapping) {
+ overlapping.bound.left = Math.min(overlapping.bound.left, mergeBound.left);
+ overlapping.bound.top = Math.min(overlapping.bound.top, mergeBound.top);
+ overlapping.bound.right = Math.max(overlapping.bound.right, mergeBound.right);
+ overlapping.bound.bottom = Math.max(overlapping.bound.bottom, mergeBound.bottom);
+ overlapping.repairsMerge = true;
+ } else {
+ repaintBounds.push({ bound: { ...mergeBound }, repairsMerge: true });
+ }
+ }
+ return repaintBounds;
+ }
+ const repaintBounds: IRepaintBound[] = [];
+ const dirtyBounds = viewportInfo.shouldCacheUpdate ? viewportInfo.diffCacheBounds : viewportInfo.diffBounds;
+ for (const dirtyBound of dirtyBounds) {
+ const clipped = getIntersectBound(dirtyBound, viewportInfo.cacheBound);
+ if (!clipped) {
+ continue;
+ }
+ if (viewportInfo.shouldCacheUpdate) {
+ repaintBounds.push({
+ bound: clipped,
+ repairsMerge: mergeRepairBounds.some((mergeBound) => getIntersectBound(clipped, mergeBound)),
+ });
} else {
- repaintBounds.push({ bound: { ...mergeRepairBound }, repairsMerge: true });
+ // Layout uses the full merge anchor; only the exposed pixels need repair.
+ for (const mergeBound of mergeRepairBounds) {
+ const intersection = getIntersectBound(clipped, mergeBound);
+ if (intersection) {
+ repaintBounds.push({ bound: intersection, repairsMerge: true });
+ }
+ }
+ }
+ }
+ return this._addNativeTextClipRepairBounds(repaintBounds, viewportInfo, mainCtx);
+ }
+
+ private _addNativeTextClipRepairBounds(
+ repaintBounds: IRepaintBound[],
+ viewportInfo: IViewportInfo,
+ mainCtx: UniverRenderingContext2D
+ ): IRepaintBound[] {
+ if (!repaintBounds.length) {
+ return repaintBounds;
+ }
+ const previous = this._getReusableScrollCacheState(mainCtx, viewportInfo);
+ const skeleton = this.getSkeleton();
+ if (!previous || !skeleton || (!viewportInfo.diffX && !viewportInfo.diffY)) {
+ return repaintBounds;
+ }
+ const current = this._getScrollCacheState(mainCtx, viewportInfo);
+ const columns = skeleton.columnWidthAccumulation;
+ const rows = skeleton.rowHeightAccumulation;
+ const headerX = skeleton.rowHeaderWidthAndMarginLeft;
+ const headerY = skeleton.columnHeaderHeightAndMarginTop;
+ const bounds: IRepaintBound[] = [];
+ const addBound = (bound: IBoundRectNoAngle, repairsMerge: boolean, repairsNativeText = false) => {
+ const clipped = getIntersectBound(bound, viewportInfo.cacheBound);
+ if (clipped) {
+ appendRepaintBound(bounds, { bound: clipped, repairsMerge, repairsNativeText });
+ }
+ };
+ const getBound = (range: IRange): IBoundRectNoAngle => ({
+ // Include bordering ink so a repaired join is never combined with its older antialiasing.
+ left: (columns[range.startColumn - 1] ?? 0) + headerX - SCROLL_REPAIR_INK_HALO / current.scaleX,
+ right: columns[range.endColumn] + headerX + SCROLL_REPAIR_INK_HALO / current.scaleX,
+ top: (rows[range.startRow - 1] ?? 0) + headerY - SCROLL_REPAIR_INK_HALO / current.scaleY,
+ bottom: rows[range.endRow] + headerY + SCROLL_REPAIR_INK_HALO / current.scaleY,
+ });
+ const addRange = (range: IRange) => {
+ addBound(getBound(range), false, true);
+ for (const merge of skeleton.worksheet.getMergedCellRange(range.startRow, range.startColumn, range.endRow, range.endColumn)) {
+ addBound(getBound(merge), true, true);
+ }
+ for (let row = range.startRow; row <= range.endRow; row++) {
+ const values = skeleton.overflowCache.getRow(row);
+ for (const column in values) {
+ const overflow = values[Number(column)];
+ if (overflow.startColumn <= range.endColumn && overflow.endColumn >= range.startColumn) {
+ addBound(getBound({
+ startRow: row,
+ endRow: row,
+ startColumn: Math.min(Number(column), overflow.startColumn),
+ endColumn: Math.max(Number(column), overflow.endColumn),
+ }), false, true);
+ }
+ }
}
+ };
+ for (const { bound, repairsMerge } of repaintBounds) {
+ addBound(bound, repairsMerge);
+ }
+ const nativeClipRanges = this._fontExtension.getNativeTextClipRepairRanges(skeleton)
+ .map((range) => ({ range, bound: getIntersectBound(getBound(range), viewportInfo.cacheBound) }));
+ let expanded = true;
+ while (expanded) {
+ expanded = false;
+ for (const { range, bound } of nativeClipRanges) {
+ if (!bound || !bounds.some((item) => getIntersectBound(item.bound, bound))
+ || bounds.some((item) => item.bound.left <= bound.left && item.bound.right >= bound.right
+ && item.bound.top <= bound.top && item.bound.bottom >= bound.bottom)) {
+ continue;
+ }
+ // Clipping native rotated or shrink-to-fit text changes its antialiasing; repair its complete cell clip.
+ addRange(range);
+ expanded = true;
+ }
+ }
+ return bounds;
+ }
+
+ private _requiresNativeFrozenEdgeRepaint(
+ mainCtx: UniverRenderingContext2D,
+ viewportInfo: IViewportInfo,
+ repaintBounds: IRepaintBound[]
+ ): boolean {
+ const vertical = viewportInfo.viewportKey === SHEET_VIEWPORT_KEY.VIEW_MAIN_LEFT && viewportInfo.diffY !== 0;
+ const horizontal = viewportInfo.viewportKey === SHEET_VIEWPORT_KEY.VIEW_MAIN_TOP && viewportInfo.diffX !== 0;
+ if (!mainCtx._context || (!vertical && !horizontal)) {
+ return false;
+ }
+ const { a, d } = mainCtx.getTransform();
+ const cache = viewportInfo.cacheBound;
+ // Native joins at a frozen band's unbuffered edges cannot mix old and newly clipped coverage.
+ return repaintBounds.some(({ bound, repairsNativeText }) => repairsNativeText
+ && ((vertical && (bound.left <= cache.left + SCROLL_REPAIR_INK_HALO / a || bound.right >= cache.right - SCROLL_REPAIR_INK_HALO / a))
+ || (horizontal && (bound.top <= cache.top + SCROLL_REPAIR_INK_HALO / d || bound.bottom >= cache.bottom - SCROLL_REPAIR_INK_HALO / d))));
+ }
+
+ private _requiresGapStripeRepaint(skeleton: SpreadsheetSkeleton, viewportInfo: IViewportInfo): boolean {
+ const { rowGaps, colGaps } = skeleton.gapConfig ?? {};
+ const { diffX, diffY } = viewportInfo;
+ if ((!diffX || !rowGaps) && (!diffY || !colGaps)) {
+ return false;
+ }
+ const range = skeleton.getCacheRangeByViewport(viewportInfo);
+ // Gap stripes start at the drawing range's edge; translated pixels can retain an older phase.
+ return (diffX !== 0 && Object.entries(rowGaps ?? {}).some(([row, gap]) =>
+ gap.size > 0 && Number(row) >= range.startRow && Number(row) <= range.endRow))
+ || (diffY !== 0 && Object.entries(colGaps ?? {}).some(([col, gap]) =>
+ gap.size > 0 && Number(col) >= range.startColumn && Number(col) <= range.endColumn));
+ }
+
+ private _requiresNativeGridlineRepaint(ctx: UniverRenderingContext2D, skeleton: SpreadsheetSkeleton, viewportInfo: IViewportInfo, hasMergeData: boolean): boolean {
+ if (!ctx._context || ctx.getSystemType() !== 'Linux' || this._forceDisableGridlines || skeleton.showGridlines === BooleanNumber.FALSE) {
+ return false;
+ }
+ const { a, d } = ctx.getTransform();
+ if (Number.isInteger(a) && Number.isInteger(d)) {
+ return false;
+ }
+ const range = skeleton.getRangeByViewBound(getOutwardRoundedBound(viewportInfo.cacheBound));
+ // Fractional Linux compound grid corners vary after cache translation; preserve the native full paint.
+ if (hasMergeData && skeleton.worksheet.getMergedCellRange(range.startRow, range.startColumn, range.endRow, range.endColumn).length) {
+ return true;
}
- return repaintBounds;
+ // Overflow anchors can be offscreen horizontally, but overflow never spans another row.
+ for (let row = range.startRow; row <= range.endRow; row++) {
+ const values = skeleton.overflowCache.getRow(row);
+ if (!values) {
+ continue;
+ }
+ for (const column in values) {
+ const overflow = values[column];
+ if (overflow.startColumn <= range.endColumn && overflow.endColumn >= range.startColumn) {
+ return true;
+ }
+ }
+ }
+ return false;
}
- paintNewAreaForScrolling(viewportInfo: IViewportInfo, param: IPaintForScrolling, mergeRepairBounds: IBoundRectNoAngle[] = []) {
+ private _requiresHorizontalResampling(mainCtx: UniverRenderingContext2D, viewportInfo: IViewportInfo): boolean {
+ const hasFractionalHorizontalEdge = viewportInfo.diffX !== 0 && this._hasFractionalViewportPixels(viewportInfo);
+ // Preserve native clip coverage for diagonal copies and horizontally scrolling frozen rows.
+ if (hasFractionalHorizontalEdge && (viewportInfo.diffY !== 0
+ || viewportInfo.viewportKey === SHEET_VIEWPORT_KEY.VIEW_MAIN_TOP)) {
+ return true;
+ }
+ if (this._getReusableScrollCacheState(mainCtx, viewportInfo)) {
+ return false;
+ }
+ if (hasFractionalHorizontalEdge) {
+ return true;
+ }
+ const transform = mainCtx.getTransform();
+ // Rounded scroll bounds can still disagree with a fractional canvas origin at pixel boundaries.
+ return viewportInfo.diffX !== 0 && (!Number.isInteger(viewportInfo.diffX * transform.a)
+ || !Number.isInteger(viewportInfo.diffY * transform.d)
+ || !Number.isInteger(transform.e) || !Number.isInteger(transform.f));
+ }
+
+ private _hasFractionalViewportPixels(viewportInfo: IViewportInfo): boolean {
+ const pixelRatio = viewportInfo.cacheCanvas!.getPixelRatio();
+ return Object.values(viewportInfo.viewPortPosition)
+ .some((value) => Math.abs(value * pixelRatio - Math.round(value * pixelRatio)) > 1e-6);
+ }
+
+ private _getScrollCacheState(mainCtx: UniverRenderingContext2D, viewportInfo: IViewportInfo): IScrollCacheState {
+ const { a, b, c, d, e, f } = mainCtx.getTransform();
+ const canvas = viewportInfo.cacheCanvas!;
+ return {
+ canvas,
+ width: canvas.getWidth(),
+ height: canvas.getHeight(),
+ pixelRatio: canvas.getPixelRatio(),
+ scaleX: a,
+ scaleY: d,
+ left: Math.round((e / a - viewportInfo.leftOrigin + viewportInfo.bufferEdgeX) * a),
+ top: Math.round((f / d - viewportInfo.topOrigin + viewportInfo.bufferEdgeY) * d),
+ axisAligned: a > 0 && d > 0 && b === 0 && c === 0,
+ viewportLeft: viewportInfo.viewPortPosition.left,
+ viewportTop: viewportInfo.viewPortPosition.top,
+ viewportRight: viewportInfo.viewPortPosition.right,
+ viewportBottom: viewportInfo.viewPortPosition.bottom,
+ };
+ }
+
+ private _getReusableScrollCacheState(mainCtx: UniverRenderingContext2D, viewportInfo: IViewportInfo): IScrollCacheState | undefined {
+ const previous = this._scrollCacheStates.get(viewportInfo.viewportKey);
+ const canvas = viewportInfo.cacheCanvas;
+ const { a, b, c, d } = mainCtx.getTransform();
+ if (!(previous?.axisAligned && canvas === previous.canvas && a > 0 && d > 0 && b === 0 && c === 0
+ && a === previous.scaleX && d === previous.scaleY && canvas.getWidth() === previous.width
+ && canvas.getHeight() === previous.height && canvas.getPixelRatio() === previous.pixelRatio
+ && viewportInfo.viewPortPosition.left === previous.viewportLeft && viewportInfo.viewPortPosition.top === previous.viewportTop
+ && viewportInfo.viewPortPosition.right === previous.viewportRight && viewportInfo.viewPortPosition.bottom === previous.viewportBottom)) {
+ return undefined;
+ }
+ const current = this._getScrollCacheState(mainCtx, viewportInfo);
+ const sceneScale = this.getScene().getAncestorScale();
+ const logicalScaleX = sceneScale.scaleX * canvas.getPixelRatio();
+ const logicalScaleY = sceneScale.scaleY * canvas.getPixelRatio();
+ // Native Canvas may report Float32 scales while viewport displacements retain scene precision.
+ const displacementScaleX = a === Math.fround(logicalScaleX) ? logicalScaleX : a;
+ const displacementScaleY = d === Math.fround(logicalScaleY) ? logicalScaleY : d;
+ // The repair strips cover one rounding pixel, not precision loss at very large coordinates.
+ return Math.abs(current.left - previous.left - viewportInfo.diffX * displacementScaleX) <= 1 + 1e-6
+ && Math.abs(current.top - previous.top - viewportInfo.diffY * displacementScaleY) <= 1 + 1e-6
+ ? previous
+ : undefined;
+ }
+
+ private _canPaintHorizontalScrollIncrementally(mainCtx: UniverRenderingContext2D, viewportInfo: IViewportInfo): boolean {
+ const cacheCanvas = viewportInfo.cacheCanvas;
+ const viewport = this.getScene().getViewport(viewportInfo.viewportKey);
+ const transform = mainCtx.getTransform();
+ // Keep the full refresh for in-place caches, missing damage, and resampling of fractional pixels.
+ return !!cacheCanvas && this._getAncestorParent()?.classType === RENDER_CLASS_TYPE.ENGINE
+ && viewport?.canvas === cacheCanvas && viewportInfo.diffBounds.length > 0 && viewportInfo.diffCacheBounds.length > 0
+ && transform.b === 0 && transform.c === 0
+ && !this._requiresHorizontalResampling(mainCtx, viewportInfo);
+ }
+
+ paintNewAreaForScrolling(
+ viewportInfo: IViewportInfo,
+ param: IPaintForScrolling,
+ mergeRepairBounds: IBoundRectNoAngle[] = [],
+ repaintBounds = this._getRepaintBounds(viewportInfo, mergeRepairBounds, param.mainCtx)
+ ) {
const { cacheCanvas, cacheCtx, mainCtx, topOrigin, leftOrigin, bufferEdgeX, bufferEdgeY, scaleX, scaleY, columnHeaderHeightAndMarginTop, rowHeaderWidthAndMarginLeft } = param;
const { diffX, diffY } = viewportInfo;
let renderCacheCanvas = cacheCanvas;
let renderCacheCtx = cacheCtx;
const viewport = this.getScene().getViewport(viewportInfo.viewportKey);
- const canSwapCache = this._getAncestorParent()?.classType === RENDER_CLASS_TYPE.ENGINE && viewport?.canvas === cacheCanvas;
-
+ // WebKit can rasterize identical native text differently in alternate contexts; keep the viewport's context.
+ const canSwapCache = this._getAncestorParent()?.classType === RENDER_CLASS_TYPE.ENGINE && viewport?.canvas === cacheCanvas
+ && mainCtx.getBrowserType() !== 'Safari' && !Tools.isIPhone();
+
+ const previousState = this._getReusableScrollCacheState(mainCtx, viewportInfo);
+ const cacheState = this._getScrollCacheState(mainCtx, viewportInfo);
+ const offsetX = previousState ? cacheState.left - previousState.left : diffX * scaleX;
+ const offsetY = previousState ? cacheState.top - previousState.top : diffY * scaleY;
if (canSwapCache) {
renderCacheCanvas = this._getScrollBufferCanvas(viewportInfo.viewportKey, cacheCanvas);
renderCacheCtx = renderCacheCanvas.getContext();
- this._copyCacheForScrolling(renderCacheCtx, cacheCanvas, diffX * scaleX, diffY * scaleY);
+ this._copyCacheForScrolling(renderCacheCtx, cacheCanvas, offsetX, offsetY);
const previousBufferCanvas = viewport.swapCacheCanvas(renderCacheCanvas);
if (previousBufferCanvas) {
this._scrollBufferCanvases.set(viewportInfo.viewportKey, previousBufferCanvas);
}
} else {
- this._copyCacheForScrolling(cacheCtx, cacheCanvas, diffX * scaleX, diffY * scaleY);
+ this._copyCacheForScrolling(cacheCtx, cacheCanvas, offsetX, offsetY);
}
this._refreshIncrementalState = true;
// Reset the ctx position to the spreadsheet content origin before drawing.
// trasnlation should be (rowHeaderWidth, colHeaderHeight) at start.
const m = mainCtx.getTransform();
- renderCacheCtx.setTransform(m.a, m.b, m.c, m.d, 0, 0);
// leftOrigin is the offset of viewport relative to sheetcorner (without considering zoom)
// - (leftOrigin - bufferEdgeX) ----> simplified to - leftOrigin + bufferEdgeX
- renderCacheCtx.translateWithPrecision(m.e / m.a - leftOrigin + bufferEdgeX, m.f / m.d - topOrigin + bufferEdgeY);
+ if (cacheState.axisAligned) {
+ renderCacheCtx.setTransform(m.a, 0, 0, m.d, cacheState.left, cacheState.top);
+ } else {
+ renderCacheCtx.setTransform(m.a, m.b, m.c, m.d, 0, 0);
+ renderCacheCtx.translateWithPrecision(m.e / m.a - leftOrigin + bufferEdgeX, m.f / m.d - topOrigin + bufferEdgeY);
+ }
- const repaintBounds = this._getRepaintBounds(viewportInfo, mergeRepairBounds);
if (repaintBounds.length) {
for (const { bound: diffBound, repairsMerge } of repaintBounds) {
const { left: diffLeft, right: diffRight, bottom: diffBottom, top: diffTop } = diffBound;
@@ -665,21 +1121,40 @@ export class Spreadsheet extends SheetComponent {
const y = diffTop - columnHeaderHeightAndMarginTop;
const w = diffRight - diffLeft;
const h = diffBottom - diffTop; // w and h must exactly match the diffarea size, otherwise when scrolling back, the clear area will be too large, causing valid content from the previous frame to be erased
-
- renderCacheCtx.clearRectByPrecision(x, y, w, h);
- // cacheCtx.fillStyle = this.testGetRandomLightColor();
- // cacheCtx.fillRectByPrecision(x, y, w, h); // x, y is diffBounds, means it's relative to scrolling distance.
+ let renderBound = diffBound;
+ let textClipBound: IBoundRectNoAngle | undefined;
renderCacheCtx.save();
- renderCacheCtx.beginPath();
- renderCacheCtx.rectByPrecision(x, y, w, h);
- renderCacheCtx.closePath();
- // The reason for clipping here is to avoid duplicate drawing (otherwise the text would be jagged, especially on Windows)
- renderCacheCtx.clip();
+ if (cacheState.axisAligned) {
+ // Avoid fractional clear/clip edges from transform round trips at non-binary zooms.
+ const left = Math.round(x * m.a) + cacheState.left;
+ const top = Math.round(y * m.d) + cacheState.top;
+ const width = Math.round((x + w) * m.a) + cacheState.left - left;
+ const height = Math.round((y + h) * m.d) + cacheState.top - top;
+ textClipBound = { left, top, right: left + width, bottom: top + height };
+ renderCacheCtx.setTransform(1, 0, 0, 1, 0, 0);
+ renderCacheCtx.clearRect(left, top, width, height);
+ renderCacheCtx.beginPath();
+ renderCacheCtx.rect(left, top, width, height);
+ renderCacheCtx.clip();
+ renderCacheCtx.setTransform(m.a, 0, 0, m.d, cacheState.left, cacheState.top);
+ // Adjacent three-pixel borders can cross the clip even when their cell does not.
+ renderBound = {
+ left: (left - cacheState.left - SCROLL_REPAIR_INK_HALO) / m.a + rowHeaderWidthAndMarginLeft,
+ right: (left + width - cacheState.left + SCROLL_REPAIR_INK_HALO) / m.a + rowHeaderWidthAndMarginLeft,
+ top: (top - cacheState.top - SCROLL_REPAIR_INK_HALO) / m.d + columnHeaderHeightAndMarginTop,
+ bottom: (top + height - cacheState.top + SCROLL_REPAIR_INK_HALO) / m.d + columnHeaderHeightAndMarginTop,
+ };
+ } else {
+ renderCacheCtx.clearRectByPrecision(x, y, w, h);
+ renderCacheCtx.beginPath();
+ renderCacheCtx.rectByPrecision(x, y, w, h);
+ renderCacheCtx.clip();
+ }
this.draw(renderCacheCtx, {
...viewportInfo,
- diffBounds: [diffBound],
- }, repairsMerge);
+ diffBounds: [renderBound],
+ }, repairsMerge, textClipBound);
renderCacheCtx.restore();
}
}
@@ -730,17 +1205,23 @@ export class Spreadsheet extends SheetComponent {
// cacheCtx.setTransform is rowHeaderWidth + viewport + scroll
const m = mainCtx.getTransform();
// cacheCtx.setTransform(m.a, m.b, m.c, m.d, m.e, m.f);
- cacheCtx.setTransform(m.a, m.b, m.c, m.d, 0, 0);
// The 'leftOrigin' is the offset of the viewport relative to the sheet corner, which is the position of cell(0, 0), and it does not consider scaling.
// - (leftOrigin - bufferEdgeX) ----> - leftOrigin + bufferEdgeX
- cacheCtx.translateWithPrecision(m.e / m.a - leftOrigin + bufferEdgeX, m.f / m.d - topOrigin + bufferEdgeY);
+ const cacheState = this._getScrollCacheState(mainCtx, viewportInfo);
+ if (cacheState.axisAligned) {
+ cacheCtx.setTransform(m.a, 0, 0, m.d, cacheState.left, cacheState.top);
+ } else {
+ cacheCtx.setTransform(m.a, m.b, m.c, m.d, 0, 0);
+ cacheCtx.translateWithPrecision(m.e / m.a - leftOrigin + bufferEdgeX, m.f / m.d - topOrigin + bufferEdgeY);
+ }
// when extension drawing, sheet content coordinate was used by sheet extension, not viewport coordinate, that means ext does not take rowheader into consideration
this.draw(cacheCtx, viewportInfo);
cacheCtx.restore();
}
override render(mainCtx: UniverRenderingContext2D, viewportInfo: IViewportInfo) {
+ this._viewportCacheFontRevision = FontCache.metricsRevision;
if (!this.visible) {
this.makeDirty(false);
return this;
@@ -758,9 +1239,17 @@ export class Spreadsheet extends SheetComponent {
return this;
}
- spreadsheetSkeleton.setStylesCache(viewportInfo, {
- scaleY: this.getParentScale().scaleY,
- });
+ if (this._canReuseStyleCache(viewportInfo)) {
+ spreadsheetSkeleton.updateVisibleRange(viewportInfo);
+ } else {
+ // Preserve the conservative border preparation for fractionally clipped viewports.
+ const stylesViewportInfo = viewportInfo.cacheCanvas && viewportInfo.diffX && this._hasFractionalViewportPixels(viewportInfo)
+ ? { ...viewportInfo, isForceDirty: true }
+ : viewportInfo;
+ spreadsheetSkeleton.setStylesCache(stylesViewportInfo, {
+ scaleY: this.getParentScale().scaleY,
+ });
+ }
const segment = spreadsheetSkeleton.rowColumnSegment;
@@ -812,6 +1301,13 @@ export class Spreadsheet extends SheetComponent {
return this;
}
+ private _canReuseStyleCache(viewportInfo: IViewportInfo): boolean {
+ return !!viewportInfo.cacheCanvas && !this.isDirty() && !this.isForceDirty()
+ && !viewportInfo.isDirty && !viewportInfo.isForceDirty && !viewportInfo.shouldCacheUpdate
+ && !viewportInfo.diffX && !viewportInfo.diffY
+ && !viewportInfo.diffBounds?.length && !viewportInfo.diffCacheBounds?.length;
+ }
+
/**
* applyCache from cache canvas
* @param cacheCanvas Source Image
@@ -930,7 +1426,9 @@ export class Spreadsheet extends SheetComponent {
private _drawAuxiliary(
ctx: UniverRenderingContext2D,
hasMergeData = true,
- redrawBackgrounds?: (ranges: IRange[]) => void
+ redrawBackgrounds?: (ranges: IRange[]) => void,
+ repairNativeGridlines = false,
+ deviceClipBound?: IBoundRectNoAngle
) {
const spreadsheetSkeleton = this.getSkeleton();
if (spreadsheetSkeleton == null) {
@@ -990,6 +1488,9 @@ export class Spreadsheet extends SheetComponent {
ctx.closePathByEnv();
ctx.stroke();
+ if (repairNativeGridlines) {
+ this._repairGridlineStroke(ctx, startX, startY, endX, endY);
+ }
const mergeVisibleRanges: IRange[] = [];
let mergeVisibleRangeStartRow = startRow;
@@ -1052,7 +1553,7 @@ export class Spreadsheet extends SheetComponent {
mergeCellRanges.push(...mergeRangeInVisible);
}
}
- this._clearRectangle(ctx, rowHeightAccumulation, columnWidthAccumulation, mergeCellRanges, redrawBackgrounds);
+ this._clearRectangle(ctx, rowHeightAccumulation, columnWidthAccumulation, mergeCellRanges, redrawBackgrounds, repairNativeGridlines, deviceClipBound);
// clear line of overflow cell
this._clearRectangle(
@@ -1060,7 +1561,9 @@ export class Spreadsheet extends SheetComponent {
rowHeightAccumulation,
columnWidthAccumulation,
overflowCache.toNativeArray(),
- redrawBackgrounds
+ redrawBackgrounds,
+ repairNativeGridlines,
+ deviceClipBound
);
// Draw gap areas AFTER merge/overflow clearing so gap visuals are always on top
@@ -1077,27 +1580,65 @@ export class Spreadsheet extends SheetComponent {
rowHeightAccumulation: number[],
columnWidthAccumulation: number[],
cellRanges?: IRange[],
- redrawBackgrounds?: (ranges: IRange[]) => void
+ redrawBackgrounds?: (ranges: IRange[]) => void,
+ repairNativeGridlines = false,
+ deviceClipBound?: IBoundRectNoAngle
) {
if (!cellRanges?.length) {
return;
}
const bounds: IBoundRectNoAngle[] = [];
- for (const range of cellRanges) {
- const { startRow, endRow, startColumn, endColumn } = range;
-
- const startY = rowHeightAccumulation[startRow - 1] ?? 0;
- const endY = rowHeightAccumulation[endRow] ?? rowHeightAccumulation[rowHeightAccumulation.length - 1];
-
- const startX = columnWidthAccumulation[startColumn - 1] ?? 0;
- const endX =
- columnWidthAccumulation[endColumn] ?? columnWidthAccumulation[columnWidthAccumulation.length - 1];
-
- ctx.clearRectByPrecision(startX, startY, endX - startX, endY - startY);
- bounds.push({ left: startX, top: startY, right: endX, bottom: endY });
+ const clearedRanges: IRange[] = [];
+ const m = ctx.getTransform();
+ const clearDevicePixels = ctx.__mode !== 'printing' && m.a > 0 && m.d > 0 && !m.b && !m.c;
+ const native = ctx._context;
+ const cullClip = deviceClipBound && clearDevicePixels && native.globalCompositeOperation === 'source-over'
+ && !native.shadowBlur && !native.shadowOffsetX && !native.shadowOffsetY
+ && (!native.filter || native.filter === 'none')
+ ? deviceClipBound
+ : undefined;
+ const inkPadding = Math.ceil(ctx.lineWidth * Math.max(m.a, m.d) * 2) + 2;
+ if (clearDevicePixels) {
+ ctx.save();
+ ctx.setTransform(1, 0, 0, 1, 0, 0);
+ }
+ try {
+ for (const range of cellRanges) {
+ const { startRow, endRow, startColumn, endColumn } = range;
+
+ const startY = rowHeightAccumulation[startRow - 1] ?? 0;
+ const endY = rowHeightAccumulation[endRow] ?? rowHeightAccumulation[rowHeightAccumulation.length - 1];
+
+ const startX = columnWidthAccumulation[startColumn - 1] ?? 0;
+ const endX =
+ columnWidthAccumulation[endColumn] ?? columnWidthAccumulation[columnWidthAccumulation.length - 1];
+
+ if (clearDevicePixels) {
+ // A fractional clear repeatedly attenuates grid intersections as cached pixels are repaired.
+ const left = Math.round(Math.round(startX * m.a) + m.e);
+ const top = Math.round(Math.round(startY * m.d) + m.f);
+ const right = Math.round(Math.round(endX * m.a) + m.e);
+ const bottom = Math.round(Math.round(endY * m.d) + m.f);
+ if (cullClip && (right + inkPadding < cullClip.left || left - inkPadding > cullClip.right
+ || bottom + inkPadding < cullClip.top || top - inkPadding > cullClip.bottom)) {
+ continue;
+ }
+ ctx.clearRect(left, top, right - left, bottom - top);
+ } else {
+ ctx.clearRectByPrecision(startX, startY, endX - startX, endY - startY);
+ }
+ bounds.push({ left: startX, top: startY, right: endX, bottom: endY });
+ clearedRanges.push(range);
+ }
+ } finally {
+ if (clearDevicePixels) {
+ ctx.restore();
+ }
}
- redrawBackgrounds?.(cellRanges);
+ if (clearedRanges.length) {
+ redrawBackgrounds?.(cullClip ? clearedRanges : cellRanges);
+ }
for (const { left, top, right, bottom } of bounds) {
// After ClearRect, the lines will become thinner, and the lines will be repaired below.
@@ -1108,10 +1649,58 @@ export class Spreadsheet extends SheetComponent {
ctx.lineToByPrecision(left, bottom);
ctx.lineToByPrecision(left, top);
ctx.stroke();
+ if (repairNativeGridlines) {
+ this._repairGridlineStroke(ctx, left, top, right, bottom, true);
+ }
ctx.closePath();
}
}
+ private _repairGridlineStroke(ctx: UniverRenderingContext2D, left: number, top: number, right: number, bottom: number, rectangle = false) {
+ const native = ctx._context;
+ const m = native.getTransform();
+ const colorSpace = native.getContextAttributes?.()?.colorSpace;
+ if (m.a !== m.d || m.a <= 0 || m.b || m.c || (colorSpace && colorSpace !== 'srgb')
+ || native.globalAlpha !== 1 || native.globalCompositeOperation !== 'source-over'
+ || typeof native.strokeStyle !== 'string' || !/^#[\da-f]{6}$/i.test(native.strokeStyle)
+ || native.getLineDash().length || native.lineCap !== 'butt' || native.lineJoin !== 'miter'
+ || native.shadowBlur || native.shadowOffsetX || native.shadowOffsetY
+ || !['rgba(0, 0, 0, 0)', 'transparent', '#00000000'].includes(native.shadowColor)
+ || (native.filter && native.filter !== 'none')) {
+ return;
+ }
+ const width = native.lineWidth * m.a;
+ const padding = Math.round(width) * 2 + 2;
+ const segments: Array<[number, number, number, number]> = [[left, top, right, top], [left, top, left, bottom]];
+ if (rectangle) {
+ segments.push([left, bottom, right, bottom], [right, top, right, bottom]);
+ }
+ native.save();
+ try {
+ native.setTransform(1, 0, 0, 1, 0, 0);
+ native.fillStyle = native.strokeStyle;
+ for (const [x0, y0, x1, y1] of segments) {
+ const horizontal = y0 === y1;
+ const start = Math.round((horizontal ? x0 : y0) * m.a) + (horizontal ? m.e : m.f);
+ const end = Math.round((horizontal ? x1 : y1) * m.a) + (horizontal ? m.e : m.f);
+ const center = Math.round((horizontal ? y0 : x0) * m.a) + (horizontal ? m.f : m.e);
+ const low = center - width / 2;
+ const high = center + width / 2;
+ const lowPixel = Math.round(low);
+ const highPixel = Math.round(high);
+ const from = Math.ceil(Math.min(start, end) + padding);
+ const to = Math.floor(Math.max(start, end) - padding);
+ if (Math.abs(low - lowPixel) > 1e-6 || Math.abs(high - highPixel) > 1e-6 || highPixel <= lowPixel || to <= from) {
+ continue;
+ }
+ // Linux software strokes can leave interior holes; preserve native corners and their coverage.
+ native.fillRect(horizontal ? from : lowPixel, horizontal ? lowPixel : from, horizontal ? to - from : highPixel - lowPixel, horizontal ? highPixel - lowPixel : to - from);
+ }
+ } finally {
+ native.restore();
+ }
+ }
+
/**
* Draw gap areas for row and column gaps.
* Clears gridlines in gap regions and fills with gap style.
diff --git a/packages/engine-render/src/context.ts b/packages/engine-render/src/context.ts
index 294edaee7f..3c6e20bca0 100644
--- a/packages/engine-render/src/context.ts
+++ b/packages/engine-render/src/context.ts
@@ -28,6 +28,7 @@ export class UniverRenderingContext2D implements CanvasRenderingContext2D {
__mode = 'rendering';
private _transformCache: Nullable<DOMMatrix>;
+ private _cacheScale = false;
private _bitmapMutationId = 0;
private _bitmapMutationTrackingDepth = 0;
readonly canvas: HTMLCanvasElement;
@@ -343,7 +344,9 @@ export class UniverRenderingContext2D implements CanvasRenderingContext2D {
* DOMMatrix.a DOMMatrix.d would affect by ctx.rotate()
*/
protected _getScale() {
- const transform = this.getTransform();
+ const transform = this._cacheScale
+ ? (this._transformCache ??= this.getTransform())
+ : this.getTransform();
const { a, b, c, d } = transform;
const scaleX = Math.sqrt(a * a + b * b);
@@ -360,6 +363,19 @@ export class UniverRenderingContext2D implements CanvasRenderingContext2D {
return this._getScale();
}
+ /** Reuse scale queries during drawing; transform methods still invalidate the cached matrix. */
+ withCachedScale(draw: () => void): void {
+ const previous = this._cacheScale;
+ this._cacheScale = true;
+ this._transformCache = null;
+ try {
+ draw();
+ } finally {
+ this._cacheScale = previous;
+ this._transformCache = null;
+ }
+ }
+
getContextAttributes(): CanvasRenderingContext2DSettings {
return this._context.getContextAttributes();
}
@@ -426,8 +442,7 @@ export class UniverRenderingContext2D implements CanvasRenderingContext2D {
}
getTransform() {
- const m = this._transformCache || this._context.getTransform();
- return m;
+ return this._context.getTransform();
}
resetTransform() {
diff --git a/packages/engine-render/src/layer.ts b/packages/engine-render/src/layer.ts
index cb5a6972c5..1ea58e4a14 100644
--- a/packages/engine-render/src/layer.ts
+++ b/packages/engine-render/src/layer.ts
@@ -15,11 +15,11 @@
*/
import type { Nullable } from '@univerjs/core';
+import { Disposable, requestImmediateMacroTask, sortRules, toDisposable } from '@univerjs/core';
import type { IBoundRectNoAngle, IViewportInfo } from './basics/vector2';
import type { UniverRenderingContext } from './context';
import type { Scene } from './scene';
import type { SceneViewer } from './scene-viewer';
-import { Disposable, requestImmediateMacroTask, sortRules, toDisposable } from '@univerjs/core';
import { BaseObject } from './base-object';
import { RENDER_CLASS_TYPE } from './basics/const';
import { Canvas } from './canvas';
@@ -34,6 +34,7 @@ export interface ILayerRenderOptions {
dirtyBounds?: IBoundRectNoAngle[];
preserveCache?: boolean;
viewportInfos?: Map<string, IViewportInfo>;
+ retainedViewportCache?: { bottom: number; viewportKeys: ReadonlySet<string> };
}
function clipContextToBounds(ctx: UniverRenderingContext, bounds: IBoundRectNoAngle[]) {
@@ -109,6 +110,7 @@ export class Layer extends Disposable {
private _cacheCanvas: Nullable<Canvas>;
private _cacheValid = false;
+ private _retainedCacheValid = false;
protected _dirty: boolean = true;
@@ -147,6 +149,7 @@ export class Layer extends Disposable {
this._cacheCanvas?.dispose();
this._cacheCanvas = null;
this._cacheValid = false;
+ this._retainedCacheValid = false;
}
isAllowCache(): boolean {
@@ -212,6 +215,7 @@ export class Layer extends Disposable {
}
removeObject(object: BaseObject | string) {
+ this.makeDirty(true);
const objects = this.getObjects();
const objectsLength = objects.length;
@@ -248,6 +252,7 @@ export class Layer extends Disposable {
}
removeObjects(objects: BaseObject[] | string[]) {
+ this.makeDirty(true);
const allObjects = this.getObjects();
const allObjectsLength = allObjects.length;
@@ -271,7 +276,11 @@ export class Layer extends Disposable {
makeDirty(state: boolean = true) {
this._dirty = state;
+ if (!state) {
+ this._retainedCacheValid = false;
+ }
if (state) {
+ this._retainedCacheValid = false;
this._cacheValid = false;
}
/**
@@ -285,7 +294,23 @@ export class Layer extends Disposable {
return this;
}
+ canReuseViewportCache(): boolean {
+ return this._allowCache && !!this._cacheCanvas &&
+ ((this._cacheValid && !this._dirty) || this._retainedCacheValid) &&
+ this.getObjectsByOrder().every((object) => !object.isDirty() && !object.isForceDirty() && object.canReuseViewportCache());
+ }
+
+ makeDirtyForViewportScroll(): void {
+ this._retainedCacheValid = this.canReuseViewportCache();
+ this._cacheValid = false;
+ this._dirty = true;
+ }
+
makeDirtyWithDebounce(state: boolean = true) {
+ if (state) {
+ this._cacheValid = false;
+ this._retainedCacheValid = false;
+ }
if (this._debounceDirtyFunc) {
this._debounceDirtyFunc();
}
@@ -319,14 +344,38 @@ export class Layer extends Disposable {
if (this.isDirty() || !this._cacheValid) {
const ctx = this._cacheCanvas.getContext();
- this._cacheCanvas.clear();
+ const retained = options.retainedViewportCache && this._retainedCacheValid &&
+ Number.isInteger(options.retainedViewportCache.bottom * this._cacheCanvas.getPixelRatio()) &&
+ options.retainedViewportCache.bottom < this._cacheCanvas.getHeight() &&
+ this._cacheCanvas.getWidth() === this.scene.getEngine()?.getCanvas().getWidth() &&
+ this._cacheCanvas.getHeight() === this.scene.getEngine()?.getCanvas().getHeight() &&
+ this.getObjectsByOrder().every((object) => !object.isDirty() && !object.isForceDirty() && object.canReuseViewportCache())
+ ? options.retainedViewportCache
+ : undefined;
+ if (retained) {
+ this.scene.getEngine()?.renderFrameTags$.next(['retainedViewportCache', this.zIndex]);
+ ctx.save();
+ try {
+ const ratio = this._cacheCanvas.getPixelRatio();
+ ctx.setTransform(1, 0, 0, 1, 0, 0);
+ ctx.clearRect(0, retained.bottom * ratio, this._cacheCanvas.getWidth() * ratio, (this._cacheCanvas.getHeight() - retained.bottom) * ratio);
+ } finally {
+ ctx.restore();
+ }
+ } else {
+ this._cacheCanvas.clear();
+ }
ctx.save();
ctx.setTransform(mainCtx.getTransform());
- this._draw(ctx, isMaxLayer, viewportInfos);
+ try {
+ this._draw(ctx, isMaxLayer, viewportInfos, retained?.viewportKeys);
+ } finally {
+ this._retainedCacheValid = false;
+ ctx.restore();
+ }
- ctx.restore();
this._cacheValid = true;
}
this._applyCache(mainCtx);
@@ -366,13 +415,19 @@ export class Layer extends Disposable {
this._cacheCanvas = new Canvas({ colorService: engine?.canvasColorService });
this._cacheValid = false;
+ this._retainedCacheValid = false;
+ this._resizeCacheCanvas();
}
- private _draw(mainCtx: UniverRenderingContext, isMaxLayer: boolean, viewportInfos?: Map<string, IViewportInfo>) {
+ private _draw(mainCtx: UniverRenderingContext, isMaxLayer: boolean, viewportInfos?: Map<string, IViewportInfo>, retainedViewportKeys?: ReadonlySet<string>) {
const viewports = this._scene.getViewports().filter((vp) => vp.shouldIntoRender());
const objects = this.getObjectsByOrder();
for (const [_index, vp] of viewports.entries()) {
- vp.render(mainCtx, objects, isMaxLayer, viewportInfos?.get(vp.viewportKey));
+ if (retainedViewportKeys?.has(vp.viewportKey)) {
+ vp.reuseCachedRender(objects, viewportInfos?.get(vp.viewportKey));
+ } else {
+ vp.render(mainCtx, objects, isMaxLayer, viewportInfos?.get(vp.viewportKey));
+ }
}
objects.forEach((o) => {
o.makeDirty(false);
@@ -401,6 +456,7 @@ export class Layer extends Disposable {
}
clear() {
+ this.makeDirty(true);
this._objects = [];
}
@@ -418,5 +474,6 @@ export class Layer extends Disposable {
this._cacheCanvas?.dispose();
this._cacheCanvas = null;
this._cacheValid = false;
+ this._retainedCacheValid = false;
}
}
diff --git a/packages/engine-render/src/scene.ts b/packages/engine-render/src/scene.ts
index 622847f787..9ecec7cc32 100644
--- a/packages/engine-render/src/scene.ts
+++ b/packages/engine-render/src/scene.ts
@@ -205,6 +205,10 @@ export class Scene extends Disposable {
private _layers: Layer[] = [];
private _viewports: Viewport[] = [];
private _preserveEngineOnRender = false;
+ private _viewportCacheReuseKey: Nullable<string> = null;
+ private _viewportCacheReuseBlocked = true;
+ private _viewportCacheReusePending = false;
+ private _renderedViewportCacheKey: Nullable<string> = null;
private _hasPostRenderCanvasMutation = false;
private _scrollbarDragViewport: Nullable<Viewport> = null;
private _isScrollbarSeeking = false;
@@ -417,6 +421,9 @@ export class Scene extends Disposable {
}
makeDirty(state: boolean = true) {
+ if (state) {
+ this.invalidateViewportCacheReuse();
+ }
this._preserveEngineOnRender = false;
this._layers.forEach((layer) => {
layer.makeDirty(state);
@@ -428,6 +435,9 @@ export class Scene extends Disposable {
}
makeDirtyForScrolling() {
+ if (this._viewportCacheReusePending) {
+ return this;
+ }
this._preserveEngineOnRender = true;
this._layers.forEach((layer) => {
layer.makeDirty(true);
@@ -435,6 +445,69 @@ export class Scene extends Disposable {
return this;
}
+ setViewportCacheReuseKey(key: Nullable<string>): void {
+ this._viewportCacheReuseKey = key;
+ this._renderedViewportCacheKey = null;
+ this.invalidateViewportCacheReuse();
+ }
+
+ invalidateViewportCacheReuse(): void {
+ this._viewportCacheReuseBlocked = true;
+ this._viewportCacheReusePending = false;
+ }
+
+ isViewportCacheReusePending(): boolean {
+ return this._viewportCacheReusePending;
+ }
+
+ makeDirtyForViewportScroll(viewport: Viewport): void {
+ const geometry = this._getViewportCacheGeometry();
+ const canReuse = viewport.viewportKey === this._viewportCacheReuseKey &&
+ !this._viewportCacheReuseBlocked && !this._preserveEngineOnRender &&
+ (!this.isDirty() || this._viewportCacheReusePending) &&
+ geometry != null && geometry.key === this._renderedViewportCacheKey &&
+ this._layers.some((layer) => layer.canReuseViewportCache()) &&
+ this._layers.every((layer) => layer.getObjectsByOrder().every((object) => !object.isDirty() && !object.isForceDirty())) &&
+ this._viewports.every((view) => !view.shouldIntoRender() || (!view.isDirty && !view.isForceDirty));
+ if (!canReuse) {
+ this.makeDirty(true);
+ return;
+ }
+ this._viewportCacheReusePending = true;
+ this._layers.forEach((layer) => layer.makeDirtyForViewportScroll());
+ }
+
+ private _getViewportCacheGeometry(): { key: string; bottom: number; viewportKeys: ReadonlySet<string> } | null {
+ const main = this._viewportCacheReuseKey ? this.getViewport(this._viewportCacheReuseKey) : null;
+ const canvas = this.getEngine()?.getCanvas();
+ if (!main || !canvas || this._parent.classType !== RENDER_CLASS_TYPE.ENGINE || this._beforeRender$.observed) {
+ return null;
+ }
+ const bottom = main.top;
+ const physicalBottom = bottom * canvas.getPixelRatio();
+ if (!Number.isInteger(bottom) || !Number.isInteger(physicalBottom) || bottom <= 0 || bottom >= canvas.getHeight()) {
+ return null;
+ }
+ const viewports = this._viewports.filter((viewport) => viewport.shouldIntoRender());
+ if (viewports.some((viewport) => viewport.top < bottom && viewport.top + viewport.height! > bottom)) {
+ return null;
+ }
+ const stationary = viewports.filter((viewport) => viewport.top + viewport.height! <= bottom);
+ if (stationary.length === 0) {
+ return null;
+ }
+ const viewportKeys = new Set(stationary.map((viewport) => viewport.viewportKey));
+ const key = JSON.stringify({
+ width: canvas.getWidth(),
+ height: canvas.getHeight(),
+ ratio: canvas.getPixelRatio(),
+ bottom,
+ transform: this.transform.getMatrix(),
+ viewports: viewports.map((viewport) => [viewport.viewportKey, viewport.left, viewport.top, viewport.width, viewport.height, viewport.viewportScrollX, viewportKeys.has(viewport.viewportKey) ? viewport.viewportScrollY : null]),
+ });
+ return { key, bottom, viewportKeys };
+ }
+
beginScrollbarDrag(viewport: Viewport) {
if (this._parent.classType !== RENDER_CLASS_TYPE.ENGINE) {
return;
@@ -487,6 +560,9 @@ export class Scene extends Disposable {
}
makeDirtyNoParent(state: boolean = true) {
+ if (state) {
+ this.invalidateViewportCacheReuse();
+ }
this._preserveEngineOnRender = false;
this._layers.forEach((layer) => {
layer.makeDirty(state);
@@ -1036,6 +1112,12 @@ export class Scene extends Disposable {
return;
}
+ const retainedViewportCache = !parentCtx && !shouldTryPreservingEngine && this._viewportCacheReusePending && !this._viewportCacheReuseBlocked
+ ? this._getViewportCacheGeometry()
+ : null;
+ const canRetainViewportCache = retainedViewportCache?.key === this._renderedViewportCacheKey &&
+ this._viewports.every((viewport) => !viewport.shouldIntoRender() || (!viewport.isDirty && !viewport.isForceDirty));
+ this._viewportCacheReusePending = false;
this._preserveEngineOnRender = false;
let layerRenderOptions: ILayerRenderOptions | undefined;
@@ -1062,10 +1144,22 @@ export class Scene extends Disposable {
this.getEngine()?.clearCanvas();
}
+ if (retainedViewportCache && canRetainViewportCache) {
+ layerRenderOptions = { ...layerRenderOptions, retainedViewportCache };
+ }
+ this.getEngine()?.renderFrameTags$.next(['retainedViewportCache', false]);
this._beforeRender$.next(canvasInstance);
- for (let i = 0, len = layers.length; i < len; i++) {
- layers[i].render(parentCtx, i === len - 1, layerRenderOptions);
+ try {
+ for (let i = 0, len = layers.length; i < len; i++) {
+ layers[i].render(parentCtx, i === len - 1, layerRenderOptions);
+ }
+ } catch (error) {
+ this.invalidateViewportCacheReuse();
+ this._renderedViewportCacheKey = null;
+ throw error;
}
+ this._renderedViewportCacheKey = parentCtx ? null : this._getViewportCacheGeometry()?.key ?? null;
+ this._viewportCacheReuseBlocked = parentCtx != null;
this._hasPostRenderCanvasMutation = this._notifyAfterRender(canvasInstance);
this._recordRenderedViewportScrollPositions();
if (shouldMeasureFullRender) {
diff --git a/packages/engine-render/src/shape/__tests__/shape-cache.spec.ts b/packages/engine-render/src/shape/__tests__/shape-cache.spec.ts
index 9eb5726bfd..828b103166 100644
--- a/packages/engine-render/src/shape/__tests__/shape-cache.spec.ts
+++ b/packages/engine-render/src/shape/__tests__/shape-cache.spec.ts
@@ -14,9 +14,10 @@
* limitations under the License.
*/
+import { Injector } from '@univerjs/core';
+import { describe, expect, it, vi } from 'vitest';
import type { IBoundRectNoAngle } from '../../basics/vector2';
import type { UniverRenderingContext } from '../../context';
-import { describe, expect, it } from 'vitest';
import { Canvas } from '../../canvas';
import { Shape } from '../shape';
@@ -32,47 +33,90 @@ class CachedShape extends Shape<Record<never, never>> {
}
}
+function createTestInjector(key: string, props?: { width: number; height: number }) {
+ return new Injector([
+ [Canvas, {
+ useFactory: (container: Injector) => container.createInstance(Canvas, { width: 200, height: 100, pixelRatio: 1 }),
+ deps: [Injector],
+ }],
+ [CachedShape, {
+ useFactory: (container: Injector) => container.createInstance(CachedShape, key, props),
+ deps: [Injector],
+ }],
+ ]);
+}
+
describe('Shape render cache', () => {
- it('reuses the cached bitmap until its local bounds change', () => {
- const mainCanvas = new Canvas({ width: 200, height: 100, pixelRatio: 1 });
- const shape = new CachedShape('cached-shape');
- const context = mainCanvas.getContext();
+ it.each(Array.from({ length: 391 }, (_, index) => index + 10))('keeps native backing pixels and cache reuse at %s percent', (percent) => {
+ const injector = createTestInjector('fractional-cache');
+ const context = injector.get(Canvas).getContext();
+ const blit = vi.spyOn(context, 'drawImage');
+ try {
+ const shape = injector.get(CachedShape);
+ for (const dpr of [1, 2, 3]) {
+ for (const scale of [percent / 100 * dpr, Math.fround(percent / 100 * dpr)]) {
+ context.setTransform(scale, 0, 0, scale, 0, 0);
+ const bounds = { left: 0, top: 0, right: 57 / scale, bottom: 12 / scale };
+ const previousDraws = shape.drawCount;
+ shape.makeDirtyNoDebounce(true);
+ shape.drawCached(context, bounds);
+ shape.drawCached(context, bounds);
+ expect(shape.drawCount, 'An unchanged native bitmap must not be repainted').toBe(previousDraws + 1);
+ const args = blit.mock.calls.at(-1)!;
+ const bitmap = args[0] as HTMLCanvasElement;
+ // A cache blit must keep the physical pixel count; a missing pixel would stretch its contents.
+ expect(bitmap.width).toBe(Math.round((args[3] as number) * scale));
+ expect(bitmap.height).toBe(Math.round((args[4] as number) * scale));
+ }
+ }
+ } finally {
+ blit.mockRestore();
+ injector.dispose();
+ }
+ });
- shape.drawCached(context, { left: -10, top: -10, right: 110, bottom: 60 });
- shape.drawCached(context, { left: -10, top: -10, right: 110, bottom: 60 });
- expect(shape.drawCount).toBe(1);
+ it('reuses the cached bitmap until its local bounds change', () => {
+ const injector = createTestInjector('cached-shape');
+ try {
+ const shape = injector.get(CachedShape);
+ const context = injector.get(Canvas).getContext();
- context.setTransform(0.5, 0, 0, 0.5, 0, 0);
- shape.drawCached(context, { left: -10, top: -10, right: 110, bottom: 60 });
- expect(shape.drawCount).toBe(2);
+ shape.drawCached(context, { left: -10, top: -10, right: 110, bottom: 60 });
+ shape.drawCached(context, { left: -10, top: -10, right: 110, bottom: 60 });
+ expect(shape.drawCount).toBe(1);
- shape.drawCached(context, { left: -10, top: -10, right: 120, bottom: 60 });
- expect(shape.drawCount).toBe(3);
+ context.setTransform(0.5, 0, 0, 0.5, 0, 0);
+ shape.drawCached(context, { left: -10, top: -10, right: 110, bottom: 60 });
+ expect(shape.drawCount).toBe(2);
- shape.dispose();
- mainCanvas.dispose();
+ shape.drawCached(context, { left: -10, top: -10, right: 120, bottom: 60 });
+ expect(shape.drawCount).toBe(3);
+ } finally {
+ injector.dispose();
+ }
});
it('keeps the cached bitmap across drag translation but invalidates it for resize', () => {
- const mainCanvas = new Canvas({ width: 200, height: 100, pixelRatio: 1 });
- const shape = new CachedShape('translated-cached-shape', { width: 100, height: 50 });
- const context = mainCanvas.getContext();
- const bounds = { left: -10, top: -10, right: 110, bottom: 60 };
-
- shape.drawCached(context, bounds);
- shape.translate(24, 18);
- shape.drawCached(context, bounds);
- expect(shape.drawCount).toBe(1);
+ const injector = createTestInjector('translated-cached-shape', { width: 100, height: 50 });
+ try {
+ const shape = injector.get(CachedShape);
+ const context = injector.get(Canvas).getContext();
+ const bounds = { left: -10, top: -10, right: 110, bottom: 60 };
- shape.transformByState({ left: 30, top: 20, width: 100, height: 50 });
- shape.drawCached(context, bounds);
- expect(shape.drawCount).toBe(1);
+ shape.drawCached(context, bounds);
+ shape.translate(24, 18);
+ shape.drawCached(context, bounds);
+ expect(shape.drawCount).toBe(1);
- shape.transformByState({ width: 120 });
- shape.drawCached(context, bounds);
- expect(shape.drawCount).toBe(2);
+ shape.transformByState({ left: 30, top: 20, width: 100, height: 50 });
+ shape.drawCached(context, bounds);
+ expect(shape.drawCount).toBe(1);
- shape.dispose();
- mainCanvas.dispose();
+ shape.transformByState({ width: 120 });
+ shape.drawCached(context, bounds);
+ expect(shape.drawCount).toBe(2);
+ } finally {
+ injector.dispose();
+ }
});
});
diff --git a/packages/engine-render/src/shape/scroll-bar.ts b/packages/engine-render/src/shape/scroll-bar.ts
index 08f87e6ffb..e906e02c9f 100644
--- a/packages/engine-render/src/shape/scroll-bar.ts
+++ b/packages/engine-render/src/shape/scroll-bar.ts
@@ -15,13 +15,13 @@
*/
import type { EventState, Nullable } from '@univerjs/core';
+import { Disposable, Tools } from '@univerjs/core';
+import { Subscription } from 'rxjs';
import type { IMouseEvent, IPointerEvent } from '../basics/i-events';
import type { Vector2 } from '../basics/vector2';
import type { UniverRenderingContext } from '../context';
import type { Scene } from '../scene';
import type { Viewport } from '../viewport';
-import { Disposable, Tools } from '@univerjs/core';
-import { Subscription } from 'rxjs';
import { hasScrollableOverflow } from '../basics/tools';
import { Transform } from '../basics/transform';
import { Rect } from './rect';
@@ -606,14 +606,18 @@ export class ScrollBar extends Disposable {
this._resizeRightBottomCorner();
}
- makeDirty(state: boolean) {
+ makeDirty(state: boolean, viewportScroll = false) {
this.horizonScrollTrack?.makeDirty(state);
this.horizonThumbRect?.makeDirty(state);
this.verticalScrollTrack?.makeDirty(state);
this.verticalThumbRect?.makeDirty(state);
this.placeholderBarRect?.makeDirty(state);
- this.makeViewDirty(state);
+ if (viewportScroll && state && !this._mainScene) {
+ this._viewport.scene.makeDirtyForViewportScroll(this._viewport);
+ } else {
+ this.makeViewDirty(state);
+ }
}
makeViewDirty(state: boolean) {
diff --git a/packages/engine-render/src/shape/shape.ts b/packages/engine-render/src/shape/shape.ts
index a2eb7dcbbb..8d1af5fe5b 100644
--- a/packages/engine-render/src/shape/shape.ts
+++ b/packages/engine-render/src/shape/shape.ts
@@ -477,6 +477,10 @@ export abstract class Shape<T extends IShapeProps> extends BaseObject {
return;
}
+ // Canvas truncates physical dimensions. Keep division/multiplication roundoff from losing a pixel.
+ const allocationWidth = width * (1 + 2 * Number.EPSILON);
+ const allocationHeight = height * (1 + 2 * Number.EPSILON);
+
const cacheBoundsChanged =
this._renderCacheBounds?.left !== bounds.left ||
this._renderCacheBounds?.top !== bounds.top ||
@@ -490,12 +494,12 @@ export abstract class Shape<T extends IShapeProps> extends BaseObject {
if (!this._renderCacheCanvas) {
this._renderCacheCanvas = new Canvas({
colorService: this.getEngine()?.canvasColorService,
- width,
- height,
+ width: allocationWidth,
+ height: allocationHeight,
pixelRatio,
});
} else if (cacheSizeChanged) {
- this._renderCacheCanvas.setSize(width, height, pixelRatio);
+ this._renderCacheCanvas.setSize(allocationWidth, allocationHeight, pixelRatio);
}
if (this.isDirty() || cacheBoundsChanged || cacheSizeChanged) {
diff --git a/packages/engine-render/src/shape/text.ts b/packages/engine-render/src/shape/text.ts
index 8840eae857..96aee461c3 100644
--- a/packages/engine-render/src/shape/text.ts
+++ b/packages/engine-render/src/shape/text.ts
@@ -15,11 +15,12 @@
*/
import type { Nullable } from '@univerjs/core';
+import { CellValueType, HorizontalAlign, TextDecoration, VerticalAlign } from '@univerjs/core';
import type { UniverRenderingContext } from '../context';
import type { IShapeProps } from './shape';
-import { CellValueType, HorizontalAlign, TextDecoration, VerticalAlign } from '@univerjs/core';
import { COLOR_BLACK_RGB } from '../basics/const';
import { DocSimpleSkeleton } from '../components/docs/layout/doc-simple-skeleton';
+import { FontCache } from '../components/docs/layout/shaping-engine/font-cache';
import { Shape } from './shape';
export interface ITextProps extends IShapeProps {
@@ -196,6 +197,30 @@ export class Text extends Shape<ITextProps> {
return totalHeight;
}
+ /** Ink bounds of the same uncropped layout used by drawPlainWith, before any canvas transform. */
+ static getPlainTextVerticalBounds(props: Pick<ITextProps, 'text' | 'fontStyle' | 'height' | 'top' | 'vAlign'>) {
+ const { text, fontStyle, height, top = 0, vAlign } = props;
+ if (!text) return { top: 0, bottom: 0 };
+ const metrics = FontCache.getMeasureText(text, fontStyle);
+ const cached = Text._layoutCache.get(`${fontStyle}\u0000${text}`);
+ // Avoid creating or evicting drawing layouts during style preparation.
+ const totalHeight = cached?.totalHeight ?? metrics.fontBoundingBoxAscent + metrics.fontBoundingBoxDescent;
+ const lines = cached?.lines ?? [{ text, height: totalHeight, baseline: metrics.fontBoundingBoxAscent }];
+ const offsetY = vAlign === VerticalAlign.TOP ? 0 : vAlign === VerticalAlign.MIDDLE ? (height - totalHeight) / 2 : height - totalHeight;
+ let lineTop = top + offsetY;
+ let inkTop = Infinity;
+ let inkBottom = -Infinity;
+ for (const line of lines) {
+ if (line.text) {
+ const ink = line.text === text ? metrics : FontCache.getMeasureText(line.text, fontStyle);
+ inkTop = Math.min(inkTop, lineTop + line.baseline - (ink.actualBoundingBoxAscent ?? line.baseline));
+ inkBottom = Math.max(inkBottom, lineTop + line.baseline + (ink.actualBoundingBoxDescent ?? line.height - line.baseline));
+ }
+ lineTop += line.height;
+ }
+ return Number.isFinite(inkTop) && Number.isFinite(inkBottom) ? { top: inkTop, bottom: inkBottom } : { top: 0, bottom: 0 };
+ }
+
private static _getCachedLayout(text: string, fontStyle: string) {
const cacheKey = `${fontStyle}\u0000${text}`;
const cached = Text._layoutCache.get(cacheKey);
diff --git a/packages/engine-render/src/viewport.ts b/packages/engine-render/src/viewport.ts
index 130f247bc8..1da04f1ed2 100644
--- a/packages/engine-render/src/viewport.ts
+++ b/packages/engine-render/src/viewport.ts
@@ -16,14 +16,14 @@
import type { EventState, IPosition, IRange, Nullable } from '@univerjs/core';
import type { Subscription } from 'rxjs';
+import { EventSubject, Tools } from '@univerjs/core';
+import { Subject } from 'rxjs';
import type { BaseObject } from './base-object';
import type { IWheelEvent } from './basics/i-events';
import type { IBoundRectNoAngle, IViewportInfo } from './basics/vector2';
import type { UniverRenderingContext } from './context';
import type { Scene } from './scene';
import type { ScrollBar } from './shape/scroll-bar';
-import { EventSubject, Tools } from '@univerjs/core';
-import { Subject } from 'rxjs';
import { RENDER_CLASS_TYPE } from './basics/const';
import { fixLineWidthByScale, hasScrollableOverflow, toPx } from './basics/tools';
import { Transform } from './basics/transform';
@@ -810,6 +810,20 @@ export class Viewport {
this._afterRender();
}
+ reuseCachedRender(objects: BaseObject[], viewportInfo?: IViewportInfo): void {
+ const info = viewportInfo ?? this.calcViewportInfo();
+ for (const object of objects) {
+ object.onViewportCacheReuse(info);
+ }
+ this.markDirty(false);
+ this.markForceDirty(false);
+ this._preViewBound = this._viewBound;
+ if (info.shouldCacheUpdate) {
+ this.preCacheBound = this._cacheBound;
+ }
+ this._afterRender();
+ }
+
private _makeDefaultViewport() {
return {
viewBound: {
@@ -1340,7 +1354,7 @@ export class Viewport {
isBarDragging: options?.isBarDragging,
isBarDragEnd: options?.isBarDragEnd,
};
- this._scrollBar?.makeDirty(true);
+ this._scrollBar?.makeDirty(true, true);
this.onScrollAfter$.emitEvent(scrollSubParam);
this._emitScrollEnd$(scrollSubParam);
@@ -1387,6 +1401,9 @@ export class Viewport {
const scrollX = afterLimitScrollXY.x;
const scrollY = afterLimitScrollXY.y;
+ const needsScrollPaint = viewportScrollX !== this.viewportScrollX || viewportScrollY !== this.viewportScrollY ||
+ scrollX !== this.scrollX || scrollY !== this.scrollY || this.isDirty || this.isForceDirty;
+
this._preScrollX = this.scrollX;
this._preScrollY = this.scrollY;
this._preViewportScrollX = this.viewportScrollX;
@@ -1408,7 +1425,10 @@ export class Viewport {
limitY: this._scrollBar?.limitY,
};
- this._scrollBar?.makeDirty(true);
+ // Preserve scroll notifications at a clamped edge without repainting an unchanged clean viewport.
+ if (needsScrollPaint) {
+ this._scrollBar.makeDirty(true, true);
+ }
// set valid scrollInfo
this.onScrollAfter$.emitEvent(scrollSubParam);
diff --git a/packages/sheets-conditional-formatting/src/render/__tests__/conditional-formatting-raster-cache.spec.ts b/packages/sheets-conditional-formatting/src/render/__tests__/conditional-formatting-raster-cache.spec.ts
new file mode 100644
index 0000000000..ad59f4cef7
--- /dev/null
+++ b/packages/sheets-conditional-formatting/src/render/__tests__/conditional-formatting-raster-cache.spec.ts
@@ -0,0 +1,174 @@
+/**
+ * Copyright 2023-present DreamNum Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import { Injector } from '@univerjs/core';
+import { UniverRenderingContext } from '@univerjs/engine-render';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { ConditionalFormattingRasterCache } from '../conditional-formatting-raster-cache';
+
+function nativeContext(canvas: HTMLCanvasElement): CanvasRenderingContext2D {
+ const smoothing: boolean[] = [];
+ const context = {
+ canvas,
+ fillStyle: '#38bdf8',
+ strokeStyle: '#2563eb',
+ imageSmoothingEnabled: true,
+ imageSmoothingQuality: 'low',
+ globalAlpha: 1,
+ globalCompositeOperation: 'source-over',
+ shadowColor: 'rgba(0, 0, 0, 0)',
+ getTransform: () => ({ a: 3, b: 0, c: 0, d: 3, e: 0.5, f: 0.5 }),
+ setTransform: vi.fn(),
+ save: vi.fn(() => smoothing.push(context.imageSmoothingEnabled)),
+ restore: vi.fn(() => { context.imageSmoothingEnabled = smoothing.pop()!; }),
+ drawImage: vi.fn(),
+ getLineDash: () => [],
+ setLineDash: vi.fn(),
+ } as unknown as CanvasRenderingContext2D;
+ return context;
+}
+
+let injector: Injector;
+
+function fixture() {
+ const native = nativeContext(document.createElement('canvas'));
+ injector.add([UniverRenderingContext, {
+ useFactory: () => injector.createInstance(UniverRenderingContext, native),
+ }]);
+ const context = injector.get(UniverRenderingContext);
+ vi.spyOn(HTMLCanvasElement.prototype, 'getContext').mockImplementation(function (this: HTMLCanvasElement) {
+ return nativeContext(this);
+ });
+ return { native, context, cache: injector.get(ConditionalFormattingRasterCache) };
+}
+
+describe('conditional formatting immutable rasters', () => {
+ beforeEach(() => {
+ injector = new Injector([[ConditionalFormattingRasterCache]]);
+ });
+
+ afterEach(() => {
+ injector.dispose();
+ vi.restoreAllMocks();
+ });
+
+ it('reuses equal physical phases, but separates geometry, content and style', () => {
+ const { cache, context, native } = fixture();
+ const draw = vi.fn();
+ try {
+ cache.draw(context, 10, 20, 24, 12, 'green', draw);
+ cache.draw(context, 30, 40, 24, 12, 'green', draw);
+ expect(draw).toHaveBeenCalledOnce();
+ const first = vi.mocked(native.drawImage).mock.calls[0][0];
+ expect(vi.mocked(native.drawImage).mock.calls[1][0]).toBe(first);
+ cache.draw(context, 30.1, 40, 24, 12, 'green', draw);
+ cache.draw(context, 30, 40, 25, 12, 'green', draw);
+ cache.draw(context, 30, 40, 24, 12, 'red', draw);
+ native.fillStyle = '#f43f5e';
+ cache.draw(context, 30, 40, 24, 12, 'green', draw);
+ expect(draw).toHaveBeenCalledTimes(5);
+ expect(context.imageSmoothingEnabled).toBe(true);
+ } finally {
+ cache.dispose();
+ }
+ });
+
+ it('does not resize, clear or repaint submitted sources when entries are evicted', () => {
+ const { cache, context, native } = fixture();
+ const draw = vi.fn();
+ for (let i = 0; i < 140; i++) {
+ cache.draw(context, 10, 20, 24, 12, String(i), draw);
+ }
+ const sources = vi.mocked(native.drawImage).mock.calls.map(([source]) => source as HTMLCanvasElement);
+ expect(new Set(sources).size).toBe(140);
+ expect(sources.every((source) => source.width === 77 && source.height === 41)).toBe(true);
+ expect(Reflect.get(cache, '_bitmaps').size).toBe(128);
+ expect(draw).toHaveBeenCalledTimes(140);
+ cache.dispose();
+ expect(sources.slice(0, 12).every((source) => source.width === 77 && source.height === 41)).toBe(true);
+ expect(sources.slice(12).every((source) => source.width === 0 && source.height === 0)).toBe(true);
+ expect(Reflect.get(cache, '_bitmaps').size).toBe(0);
+ expect(Reflect.get(cache, '_pixels')).toBe(0);
+ expect(() => cache.draw(context, 0, 0, 24, 12, '', draw)).toThrow('disposed');
+ });
+
+ it('bounds retained pixel memory independently of the number of entries', () => {
+ const { cache, context } = fixture();
+ for (let i = 0; i < 12; i++) {
+ cache.draw(context, 0, 0, 100, 100, String(i), vi.fn());
+ }
+ expect(Reflect.get(cache, '_bitmaps').size).toBeLessThan(12);
+ expect(Reflect.get(cache, '_pixels')).toBeLessThanOrEqual(512 * 1024);
+ cache.dispose();
+ });
+
+ it('includes the entire physical stroke at high scale', () => {
+ const { cache, context, native } = fixture();
+ vi.spyOn(native, 'getTransform').mockReturnValue({ a: 6, b: 0, c: 0, d: 6, e: 60, f: 60 } as DOMMatrix);
+ const draw = vi.fn();
+ cache.draw(context, 0, 0, 24, 12, 'gradient', draw, 1);
+ const [paint] = draw.mock.calls[0];
+ expect([paint.canvas.width, paint.canvas.height]).toEqual([152, 80]);
+ expect(paint._context.setTransform).toHaveBeenCalledWith(6, 0, 0, 6, 4, 4);
+ expect(native.drawImage).toHaveBeenCalledWith(paint.canvas, 56, 56);
+ cache.dispose();
+ });
+
+ it.each(['printing', 'alpha', 'composition', 'rotation', 'shadow', 'filter', 'gradient-style', 'oversized'])('retains native fallback for %s', (mode) => {
+ const { cache, context, native } = fixture();
+ if (mode === 'printing') {
+ context.__mode = 'printing';
+ }
+ if (mode === 'alpha') {
+ native.globalAlpha = 0.5;
+ }
+ if (mode === 'composition') {
+ native.globalCompositeOperation = 'destination-out';
+ }
+ if (mode === 'rotation') {
+ vi.spyOn(native, 'getTransform').mockReturnValue({ a: 1, b: 1, c: 0, d: 1 } as DOMMatrix);
+ }
+ if (mode === 'shadow') {
+ native.shadowBlur = 2;
+ }
+ if (mode === 'filter') {
+ native.filter = 'blur(2px)';
+ }
+ if (mode === 'gradient-style') {
+ native.fillStyle = {} as CanvasGradient;
+ }
+ const draw = vi.fn();
+ cache.draw(context, 10, 20, mode === 'oversized' ? 1_000_000 : 24, 12, '', draw);
+ expect(draw).toHaveBeenCalledExactlyOnceWith(context, 10, 20);
+ expect(native.drawImage).not.toHaveBeenCalled();
+ cache.dispose();
+ });
+
+ it('does not retain a failed raster and restores destination state after a failed submission', () => {
+ const { cache, context, native } = fixture();
+ expect(() => cache.draw(context, 0, 0, 24, 12, '', () => {
+ throw new Error('paint');
+ })).toThrow('paint');
+ expect(Reflect.get(cache, '_bitmaps').size).toBe(0);
+ vi.mocked(native.drawImage).mockImplementation(() => {
+ throw new Error('submit');
+ });
+ expect(() => cache.draw(context, 0, 0, 24, 12, '', vi.fn())).toThrow('submit');
+ expect(native.restore).toHaveBeenCalledOnce();
+ expect(context.imageSmoothingEnabled).toBe(true);
+ cache.dispose();
+ });
+});
diff --git a/packages/sheets-conditional-formatting/src/render/__tests__/conditional-formatting-render.spec.ts b/packages/sheets-conditional-formatting/src/render/__tests__/conditional-formatting-render.spec.ts
deleted file mode 100644
index f510d10229..0000000000
--- a/packages/sheets-conditional-formatting/src/render/__tests__/conditional-formatting-render.spec.ts
+++ /dev/null
@@ -1,287 +0,0 @@
-/**
- * Copyright 2023-present DreamNum Co., Ltd.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-import type { IRange } from '@univerjs/core';
-import { describe, expect, it, vi } from 'vitest';
-import { IIconSetType } from '../../models/icon-map';
-import { DataBar } from '../data-bar.render';
-import { ConditionalFormattingIcon } from '../icon.render';
-
-function createCtx() {
- const gradient = { addColorStop: vi.fn() };
- return {
- save: vi.fn(),
- restore: vi.fn(),
- beginPath: vi.fn(),
- moveTo: vi.fn(),
- lineTo: vi.fn(),
- arcTo: vi.fn(),
- closePath: vi.fn(),
- fill: vi.fn(),
- stroke: vi.fn(),
- drawImage: vi.fn(),
- createLinearGradient: vi.fn(() => gradient),
- fillStyle: '',
- strokeStyle: '',
- lineWidth: 0,
- gradient,
- } as any;
-}
-
-function createCellBounds(row: number, col: number, overrides?: Record<string, unknown>) {
- const startX = col * 80;
- const startY = row * 24;
- return {
- startRow: row,
- endRow: row,
- startColumn: col,
- endColumn: col,
- startX,
- endX: startX + 80,
- startY,
- endY: startY + 24,
- isMerged: false,
- isMergedMainCell: false,
- mergeInfo: {
- startRow: row,
- endRow: row,
- startColumn: col,
- endColumn: col,
- startX,
- endX: startX + 80,
- startY,
- endY: startY + 24,
- },
- ...overrides,
- };
-}
-
-function createSkeleton(cells: Record<string, unknown>, hiddenRows = new Set<number>(), hiddenCols = new Set<number>()) {
- return {
- rowColumnSegment: { startRow: 0, endRow: 2, startColumn: 0, endColumn: 2 },
- worksheet: {
- getUnitId: () => 'unit-1',
- getSheetId: () => 'sheet-1',
- getMergeData: () => [],
- getRowVisible: (row: number) => !hiddenRows.has(row),
- getColVisible: (col: number) => !hiddenCols.has(col),
- getCell: vi.fn((row: number, col: number) => cells[`${row},${col}`]),
- },
- getCellWithCoordByIndex: (row: number, col: number) => createCellBounds(row, col),
- } as any;
-}
-
-describe('conditional formatting render extensions', () => {
- it('draws data bars for positive and negative cell values in visible cells', () => {
- const ctx = createCtx();
- const skeleton = createSkeleton({
- '0,0': {
- dataBar: {
- color: '#2f56ef',
- value: 75,
- startPoint: 25,
- isGradient: false,
- isShowValue: true,
- },
- },
- '0,1': {
- dataBar: {
- color: '#f45531',
- value: -50,
- startPoint: 60,
- isGradient: true,
- isShowValue: true,
- },
- },
- '1,0': {
- dataBar: {
- color: '#111111',
- value: 100,
- startPoint: 0,
- isGradient: false,
- isShowValue: true,
- },
- },
- }, new Set([1]));
-
- new DataBar().draw(ctx, { scaleX: 1, scaleY: 1 }, skeleton, [
- { startRow: 0, endRow: 1, startColumn: 0, endColumn: 1 },
- ]);
-
- expect(ctx.save).toHaveBeenCalled();
- expect(ctx.fill).toHaveBeenCalledTimes(2);
- expect(ctx.createLinearGradient).toHaveBeenCalledTimes(1);
- expect(ctx.gradient.addColorStop).toHaveBeenCalledWith(0, 'rgb(255 255 255)');
- expect(ctx.gradient.addColorStop).toHaveBeenCalledWith(1, '#f45531');
- expect(ctx.stroke).toHaveBeenCalledTimes(1);
- expect(ctx.restore).toHaveBeenCalled();
- });
-
- it('skips data bar drawing when worksheet is missing or bar dimensions collapse', () => {
- const ctx = createCtx();
- const dataBar = new DataBar();
- expect(dataBar.draw(ctx, { scaleX: 1, scaleY: 1 }, { worksheet: undefined } as any, [])).toBe(false);
-
- (dataBar as any)._drawRectWithRoundedCorner(ctx, 0, 0, 0, 10, true, true, true, true);
- (dataBar as any)._drawRectWithRoundedCorner(ctx, 0, 0, 10, 0, true, true, true, true);
- expect(ctx.beginPath).not.toHaveBeenCalled();
- });
-
- it('skips data bar cell visits only when a configured rule-range resolver confirms no matching rule', () => {
- const ctx = createCtx();
- const skeleton = createSkeleton({
- '0,0': {
- dataBar: {
- color: '#2f56ef',
- value: 75,
- startPoint: 25,
- isGradient: false,
- isShowValue: true,
- },
- },
- });
- const dataBar = new DataBar();
- const resolver = vi.fn(() => []);
- dataBar.setRenderRangeResolver(resolver);
-
- const ranges = [{ startRow: 0, endRow: 0, startColumn: 0, endColumn: 0 }];
- dataBar.draw(ctx, { scaleX: 1, scaleY: 1 }, skeleton, ranges);
-
- expect(resolver).toHaveBeenCalledWith('unit-1', 'sheet-1', ranges);
- expect(skeleton.worksheet.getCell).not.toHaveBeenCalled();
- expect(ctx.save).not.toHaveBeenCalled();
- });
-
- it('falls back to the original data bar path when indexed ranges are unavailable or merges exist', () => {
- const ctx = createCtx();
- const skeleton = createSkeleton({
- '0,0': {
- dataBar: {
- color: '#2f56ef',
- value: 75,
- startPoint: 25,
- isGradient: false,
- isShowValue: true,
- },
- },
- });
- const dataBar = new DataBar();
- const resolver = vi.fn<() => IRange[] | null>(() => null);
- dataBar.setRenderRangeResolver(resolver);
-
- const ranges = [{ startRow: 0, endRow: 0, startColumn: 0, endColumn: 0 }];
- dataBar.draw(ctx, { scaleX: 1, scaleY: 1 }, skeleton, ranges);
- expect(ctx.fill).toHaveBeenCalledTimes(1);
-
- resolver.mockReturnValue([]);
- skeleton.worksheet.getMergeData = () => [ranges[0]] as never;
- dataBar.draw(ctx, { scaleX: 1, scaleY: 1 }, skeleton, ranges);
-
- expect(resolver).toHaveBeenCalledTimes(1);
- expect(ctx.fill).toHaveBeenCalledTimes(2);
- });
-
- it('draws configured conditional-formatting icons and skips unavailable icons', () => {
- const ctx = createCtx();
- const icon = new ConditionalFormattingIcon();
- const nativeImage = document.createElement('img');
- (icon as any)._imageMap.set(`${IIconSetType.threeArrows}_0`, nativeImage);
-
- const skeleton = createSkeleton({
- '0,0': {
- iconSet: {
- iconType: IIconSetType.threeArrows,
- iconId: '0',
- isShowValue: true,
- },
- },
- '0,1': {
- iconSet: {
- iconType: IIconSetType.empty,
- iconId: '0',
- isShowValue: true,
- },
- },
- '0,2': {
- iconSet: {
- iconType: IIconSetType.threeArrows,
- iconId: '99',
- isShowValue: true,
- },
- },
- });
-
- icon.draw(ctx, { scaleX: 1, scaleY: 1 }, skeleton, [
- { startRow: 0, endRow: 0, startColumn: 0, endColumn: 2 },
- ]);
-
- expect(ctx.drawImage).toHaveBeenCalledTimes(1);
- expect(ctx.drawImage).toHaveBeenCalledWith(nativeImage, 2, 4.5, 15, 15);
- });
-
- it('skips icon drawing for missing worksheet and cells too small for the icon', () => {
- const ctx = createCtx();
- const icon = new ConditionalFormattingIcon();
- const nativeImage = document.createElement('img');
- (icon as any)._imageMap.set(`${IIconSetType.threeArrows}_0`, nativeImage);
-
- expect(icon.draw(ctx, { scaleX: 1, scaleY: 1 }, { worksheet: undefined } as any, [])).toBe(false);
-
- const skeleton = createSkeleton({
- '0,0': {
- iconSet: {
- iconType: IIconSetType.threeArrows,
- iconId: '0',
- isShowValue: true,
- },
- },
- });
- skeleton.getCellWithCoordByIndex = () => createCellBounds(0, 0, {
- endX: 10,
- endY: 10,
- mergeInfo: {
- startRow: 0,
- endRow: 0,
- startColumn: 0,
- endColumn: 0,
- startX: 0,
- endX: 10,
- startY: 0,
- endY: 10,
- },
- }) as any;
-
- icon.draw(ctx, { scaleX: 1, scaleY: 1 }, skeleton, [
- { startRow: 0, endRow: 0, startColumn: 0, endColumn: 0 },
- ]);
- expect(ctx.drawImage).not.toHaveBeenCalled();
- });
-
- it('skips icon cell visits when a configured rule-range resolver confirms no matching rule', () => {
- const ctx = createCtx();
- const skeleton = createSkeleton({});
- const icon = new ConditionalFormattingIcon();
- const resolver = vi.fn(() => []);
- icon.setRenderRangeResolver(resolver);
-
- const ranges = [{ startRow: 0, endRow: 0, startColumn: 0, endColumn: 2 }];
- icon.draw(ctx, { scaleX: 1, scaleY: 1 }, skeleton, ranges);
-
- expect(resolver).toHaveBeenCalledWith('unit-1', 'sheet-1', ranges);
- expect(skeleton.worksheet.getCell).not.toHaveBeenCalled();
- expect(ctx.save).not.toHaveBeenCalled();
- });
-});
diff --git a/packages/sheets-conditional-formatting/src/render/__tests__/data-bar.render.spec.ts b/packages/sheets-conditional-formatting/src/render/__tests__/data-bar.render.spec.ts
new file mode 100644
index 0000000000..7fdd8adb2e
--- /dev/null
+++ b/packages/sheets-conditional-formatting/src/render/__tests__/data-bar.render.spec.ts
@@ -0,0 +1,462 @@
+/**
+ * Copyright 2023-present DreamNum Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import type { ICellData, IRange, IWorkbookData, Workbook } from '@univerjs/core';
+import { BooleanNumber, LocaleService, LocaleType, ObjectMatrix, ThemeService, Univer, UniverInstanceType } from '@univerjs/core';
+import { CanvasColorService, ICanvasColorService, SpreadsheetSkeleton, UniverRenderingContext } from '@univerjs/engine-render';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { IIconSetType } from '../../models/icon-map';
+import { DataBar } from '../data-bar.render';
+import { ConditionalFormattingIcon } from '../icon.render';
+
+function createCtx(canvasColorService?: ICanvasColorService) {
+ const gradient = { addColorStop: vi.fn() };
+ const native = {
+ canvas: document.createElement('canvas'),
+ save: vi.fn(),
+ restore: vi.fn(),
+ beginPath: vi.fn(),
+ moveTo: vi.fn(),
+ lineTo: vi.fn(),
+ arcTo: vi.fn(),
+ closePath: vi.fn(),
+ fill: vi.fn(),
+ stroke: vi.fn(),
+ drawImage: vi.fn(),
+ createLinearGradient: vi.fn(() => gradient),
+ fillStyle: '',
+ strokeStyle: '',
+ lineWidth: 0,
+ getTransform: vi.fn(),
+ } as unknown as CanvasRenderingContext2D;
+ const injector = univer.__getInjector();
+ injector.add([UniverRenderingContext, {
+ useFactory: () => injector.createInstance(UniverRenderingContext, native, { canvasColorService }),
+ }]);
+ const context = injector.get(UniverRenderingContext);
+ for (const method of ['save', 'restore', 'beginPath', 'fill', 'stroke', 'drawImage', 'createLinearGradient'] as const) {
+ vi.spyOn(context, method);
+ }
+ return Object.assign(context, { gradient });
+}
+
+let univer: Univer;
+
+function createSkeleton(
+ cells: Record<string, unknown>,
+ hiddenRows = new Set<number>(),
+ hiddenCols = new Set<number>(),
+ mergeData: IRange[] = [],
+ size = { width: 80, height: 24 }
+) {
+ const cellData = new ObjectMatrix<ICellData>();
+ for (const [position, cell] of Object.entries(cells)) {
+ const [row, column] = position.split(',').map(Number);
+ cellData.setValue(row, column, cell as ICellData);
+ }
+ const workbook = univer.createUnit<IWorkbookData, Workbook>(UniverInstanceType.UNIVER_SHEET, {
+ id: 'unit-1',
+ sheetOrder: ['sheet-1'],
+ sheets: {
+ 'sheet-1': {
+ id: 'sheet-1',
+ name: 'Sheet',
+ rowCount: Math.max(3, ...mergeData.map((range) => range.endRow + 1)),
+ columnCount: Math.max(3, ...mergeData.map((range) => range.endColumn + 1)),
+ defaultColumnWidth: size.width,
+ defaultRowHeight: size.height,
+ rowData: Object.fromEntries([...hiddenRows].map((row) => [row, { hd: BooleanNumber.TRUE }])),
+ columnData: Object.fromEntries([...hiddenCols].map((column) => [column, { hd: BooleanNumber.TRUE }])),
+ cellData: cellData.getMatrix(),
+ mergeData,
+ },
+ },
+ });
+ const injector = univer.__getInjector();
+ injector.add([SpreadsheetSkeleton, {
+ useFactory: () => injector.createInstance(SpreadsheetSkeleton, workbook.getActiveSheet()!, workbook.getStyles()),
+ }]);
+ const skeleton = injector.get(SpreadsheetSkeleton);
+ vi.spyOn(skeleton.worksheet, 'getCell');
+ return skeleton;
+}
+
+describe('conditional formatting render extensions', () => {
+ beforeEach(() => {
+ univer = new Univer();
+ const injector = univer.__getInjector();
+ injector.add([DataBar]);
+ injector.add([ConditionalFormattingIcon]);
+ const locale = injector.get(LocaleService);
+ locale.load({ [LocaleType.EN_US]: {} });
+ locale.setLocale(LocaleType.EN_US);
+ locale.setDirection('ltr');
+ });
+
+ afterEach(() => {
+ vi.unstubAllGlobals();
+ univer.dispose();
+ vi.restoreAllMocks();
+ });
+
+ it.each(['safari', 'iphone', 'printing', 'server'])('draws real data bars natively on %s', (mode) => {
+ const ctx = createCtx();
+ Object.assign(ctx._context, {
+ globalAlpha: 1,
+ globalCompositeOperation: 'source-over',
+ shadowColor: 'rgba(0, 0, 0, 0)',
+ getLineDash: () => [],
+ });
+ vi.mocked(ctx._context.getTransform).mockReturnValue({ a: 3, b: 0, c: 0, d: 3, e: 0.5, f: 0.5 } as DOMMatrix);
+ const skeleton = createSkeleton({
+ '0,0': { dataBar: { color: '#38bdf8', value: 75, startPoint: 0, isGradient: false, isShowValue: true } },
+ });
+ skeleton.calculate();
+ const allocation = vi.spyOn(document, 'createElement');
+ if (mode === 'safari' || mode === 'iphone') {
+ vi.spyOn(navigator, 'userAgent', 'get').mockReturnValue(mode === 'safari' ? 'Safari' : 'iPhone Chrome Safari');
+ } else {
+ vi.stubGlobal('navigator', undefined);
+ if (mode === 'printing') {
+ ctx.__mode = 'printing';
+ } else {
+ vi.stubGlobal('document', undefined);
+ }
+ }
+
+ univer.__getInjector().get(DataBar).draw(ctx, { scaleX: 1, scaleY: 1 }, skeleton, [
+ { startRow: 0, endRow: 0, startColumn: 0, endColumn: 0 },
+ ]);
+
+ expect(ctx.fill).toHaveBeenCalledOnce();
+ expect(ctx._context.moveTo).toHaveBeenCalled();
+ expect(allocation).not.toHaveBeenCalled();
+ expect(ctx.drawImage).not.toHaveBeenCalled();
+ });
+
+ it('reuses real bar rasters, separates changed bar styles and releases owned images on disposal', () => {
+ const ctx = createCtx();
+ const smoothing: boolean[] = [];
+ Object.assign(ctx._context, {
+ imageSmoothingEnabled: true,
+ globalAlpha: 1,
+ globalCompositeOperation: 'source-over',
+ shadowColor: 'rgba(0, 0, 0, 0)',
+ getLineDash: () => [],
+ setTransform: vi.fn(),
+ });
+ vi.mocked(ctx._context.save).mockImplementation(() => {
+ smoothing.push(ctx._context.imageSmoothingEnabled);
+ });
+ vi.mocked(ctx._context.restore).mockImplementation(() => {
+ ctx._context.imageSmoothingEnabled = smoothing.pop()!;
+ });
+ vi.mocked(ctx._context.getTransform).mockReturnValue({ a: 3, b: 0, c: 0, d: 3, e: -162.5, f: 100.5 } as DOMMatrix);
+ vi.spyOn(navigator, 'userAgent', 'get').mockReturnValue('Chrome Safari');
+ vi.spyOn(HTMLCanvasElement.prototype, 'getContext').mockImplementation(function (this: HTMLCanvasElement) {
+ return {
+ ...ctx._context,
+ canvas: this,
+ fill: vi.fn(),
+ stroke: vi.fn(),
+ drawImage: vi.fn(),
+ setLineDash: vi.fn(),
+ } as CanvasRenderingContext2D;
+ });
+ const skeleton = createSkeleton({
+ '0,0': { dataBar: { color: '#38bdf8', value: 75, startPoint: 0, isGradient: false, isShowValue: true } },
+ });
+ skeleton.calculate();
+ const bar = univer.__getInjector().get(DataBar);
+ const ranges = [{ startRow: 0, endRow: 0, startColumn: 0, endColumn: 0 }];
+ bar.draw(ctx, { scaleX: 1, scaleY: 1 }, skeleton, ranges);
+ const bitmap = vi.mocked(ctx._context.drawImage).mock.calls[0][0] as HTMLCanvasElement;
+ bar.draw(ctx, { scaleX: 1, scaleY: 1 }, skeleton, ranges);
+ expect(vi.mocked(ctx._context.drawImage).mock.calls[1][0]).toBe(bitmap);
+ expect(bitmap.width).toBeGreaterThan(1);
+ expect(bitmap.height).toBeGreaterThan(1);
+ expect(ctx.fill).not.toHaveBeenCalled();
+ const cell = skeleton.worksheet.getCellRaw(0, 0)!;
+ skeleton.worksheet.getCellMatrix().setValue(0, 0, {
+ ...cell,
+ dataBar: { color: '#f45531', value: -75, startPoint: 100, isGradient: true, isShowValue: true },
+ } as ICellData);
+ bar.draw(ctx, { scaleX: 1, scaleY: 1 }, skeleton, ranges);
+ const changed = vi.mocked(ctx._context.drawImage).mock.calls[2][0] as HTMLCanvasElement;
+ expect(changed).not.toBe(bitmap);
+ bar.dispose();
+ expect([bitmap.width, bitmap.height, changed.width, changed.height]).toEqual([0, 0, 0, 0]);
+ });
+
+ it.each([
+ { darkMode: false, isGradient: false },
+ { darkMode: false, isGradient: true },
+ { darkMode: true, isGradient: false },
+ { darkMode: true, isGradient: true },
+ ])('resolves native data bar colors once (dark: $darkMode, gradient: $isGradient)', ({ darkMode, isGradient }) => {
+ const injector = univer.__getInjector();
+ injector.get(ThemeService).setDarkMode(darkMode);
+ injector.add([ICanvasColorService, { useClass: CanvasColorService }]);
+ const colors = injector.get(ICanvasColorService);
+ const color = '#38bdf8';
+ const expected = colors.getRenderColor(color);
+ const ctx = createCtx(colors);
+ ctx.__mode = 'printing';
+ const skeleton = createSkeleton({
+ '0,0': { dataBar: { color, value: 75, startPoint: 0, isGradient, isShowValue: true } },
+ });
+ skeleton.calculate();
+
+ injector.get(DataBar).draw(ctx, { scaleX: 1, scaleY: 1 }, skeleton, [
+ { startRow: 0, endRow: 0, startColumn: 0, endColumn: 0 },
+ ]);
+
+ expect(isGradient ? ctx._context.strokeStyle : ctx._context.fillStyle).toBe(expected);
+ expect(ctx.fill).toHaveBeenCalledOnce();
+ });
+
+ it('draws data bars for positive and negative cell values in visible cells', () => {
+ const ctx = createCtx();
+ const skeleton = createSkeleton({
+ '0,0': {
+ dataBar: {
+ color: '#2f56ef',
+ value: 75,
+ startPoint: 25,
+ isGradient: false,
+ isShowValue: true,
+ },
+ },
+ '0,1': {
+ dataBar: {
+ color: '#f45531',
+ value: -50,
+ startPoint: 60,
+ isGradient: true,
+ isShowValue: true,
+ },
+ },
+ '1,0': {
+ dataBar: {
+ color: '#111111',
+ value: 100,
+ startPoint: 0,
+ isGradient: false,
+ isShowValue: true,
+ },
+ },
+ }, new Set([1]));
+
+ univer.__getInjector().get(DataBar).draw(ctx, { scaleX: 1, scaleY: 1 }, skeleton, [
+ { startRow: 0, endRow: 1, startColumn: 0, endColumn: 1 },
+ ]);
+
+ expect(ctx.save).toHaveBeenCalled();
+ expect(ctx.fill).toHaveBeenCalledTimes(2);
+ expect(ctx.createLinearGradient).toHaveBeenCalledTimes(1);
+ expect(ctx.gradient.addColorStop).toHaveBeenCalledWith(0, 'rgb(255 255 255)');
+ expect(ctx.gradient.addColorStop).toHaveBeenCalledWith(1, '#f45531');
+ expect(ctx.stroke).toHaveBeenCalledTimes(1);
+ expect(ctx.restore).toHaveBeenCalled();
+ });
+
+ it('skips data bar drawing when worksheet is missing or bar dimensions collapse', () => {
+ const ctx = createCtx();
+ const dataBar = univer.__getInjector().get(DataBar);
+ expect(dataBar.draw(ctx, { scaleX: 1, scaleY: 1 }, { worksheet: undefined } as any, [])).toBe(false);
+
+ (dataBar as any)._drawRectWithRoundedCorner(ctx, 0, 0, 0, 10, true, true, true, true);
+ (dataBar as any)._drawRectWithRoundedCorner(ctx, 0, 0, 10, 0, true, true, true, true);
+ expect(ctx.beginPath).not.toHaveBeenCalled();
+ });
+
+ it('skips data bar cell visits only when a configured rule-range resolver confirms no matching rule', () => {
+ const ctx = createCtx();
+ const skeleton = createSkeleton({
+ '0,0': {
+ dataBar: {
+ color: '#2f56ef',
+ value: 75,
+ startPoint: 25,
+ isGradient: false,
+ isShowValue: true,
+ },
+ },
+ });
+ const dataBar = univer.__getInjector().get(DataBar);
+ const resolver = vi.fn(() => []);
+ dataBar.setRenderRangeResolver(resolver);
+
+ const ranges = [{ startRow: 0, endRow: 0, startColumn: 0, endColumn: 0 }];
+ dataBar.draw(ctx, { scaleX: 1, scaleY: 1 }, skeleton, ranges);
+
+ expect(resolver).toHaveBeenCalledWith('unit-1', 'sheet-1', ranges);
+ expect(skeleton.worksheet.getCell).not.toHaveBeenCalled();
+ expect(ctx.save).not.toHaveBeenCalled();
+ });
+
+ it('falls back when indexed ranges are unavailable but skips unmatched merged cells', () => {
+ const ctx = createCtx();
+ const skeleton = createSkeleton({
+ '0,0': {
+ dataBar: {
+ color: '#2f56ef',
+ value: 75,
+ startPoint: 25,
+ isGradient: false,
+ isShowValue: true,
+ },
+ },
+ });
+ const dataBar = univer.__getInjector().get(DataBar);
+ const resolver = vi.fn<() => IRange[] | null>(() => null);
+ dataBar.setRenderRangeResolver(resolver);
+
+ const ranges = [{ startRow: 0, endRow: 0, startColumn: 0, endColumn: 0 }];
+ dataBar.draw(ctx, { scaleX: 1, scaleY: 1 }, skeleton, ranges);
+ expect(ctx.fill).toHaveBeenCalledTimes(1);
+
+ resolver.mockReturnValue([]);
+ skeleton.worksheet.setMergeData([ranges[0]]);
+ dataBar.draw(ctx, { scaleX: 1, scaleY: 1 }, skeleton, ranges);
+
+ expect(resolver).toHaveBeenCalledTimes(2);
+ expect(ctx.fill).toHaveBeenCalledTimes(1);
+ });
+
+ it.each(['dataBar', 'icon'])('does not scan merged cells without %s rules', (kind) => {
+ const merge = { startRow: 0, endRow: 100000, startColumn: 0, endColumn: 20 };
+ const skeleton = createSkeleton({}, undefined, undefined, [merge]);
+ const extension = kind === 'dataBar' ? univer.__getInjector().get(DataBar) : univer.__getInjector().get(ConditionalFormattingIcon);
+ const resolver = vi.fn(() => []);
+ extension.setRenderRangeResolver(resolver);
+
+ extension.draw(createCtx(), { scaleX: 1, scaleY: 1 }, skeleton, [
+ { startRow: 10, endRow: 12, startColumn: 4, endColumn: 5 },
+ ]);
+
+ expect(resolver).toHaveBeenCalledOnce();
+ expect(skeleton.worksheet.getCell).not.toHaveBeenCalled();
+ });
+
+ it.each(['dataBar', 'icon'])('keeps offscreen merged %s anchors and only visits visible repair cells', (kind) => {
+ const ctx = createCtx();
+ const anchor = { startRow: 0, endRow: 0, startColumn: 0, endColumn: 0 };
+ const merge = { ...anchor, endRow: 100000, endColumn: 20 };
+ const repair = { startRow: 10, endRow: 12, startColumn: 4, endColumn: 5 };
+ const skeleton = createSkeleton({
+ '0,0': {
+ dataBar: { color: '#2f56ef', value: 75, startPoint: 0, isGradient: false },
+ iconSet: { iconType: IIconSetType.threeArrows, iconId: '0' },
+ },
+ }, new Set([10]), new Set([4]), [merge]);
+ const extension = kind === 'dataBar' ? univer.__getInjector().get(DataBar) : univer.__getInjector().get(ConditionalFormattingIcon);
+ if (extension instanceof ConditionalFormattingIcon) {
+ (extension as any)._imageMap.set(`${IIconSetType.threeArrows}_0`, document.createElement('img'));
+ }
+ const resolver = vi.fn((_unitId: string, _sheetId: string, ranges: IRange[]) => (
+ ranges.some((range) => range.startRow === 0 && range.startColumn === 0) ? [anchor] : []
+ ));
+ extension.setRenderRangeResolver(resolver);
+
+ extension.draw(ctx, { scaleX: 1, scaleY: 1 }, skeleton, [repair]);
+
+ expect(resolver).toHaveBeenCalledOnce();
+ expect(kind === 'dataBar' ? ctx.fill : ctx.drawImage).toHaveBeenCalledOnce();
+ expect(vi.mocked(skeleton.worksheet.getCell).mock.calls.length).toBeLessThanOrEqual(4);
+ expect(vi.mocked(skeleton.worksheet.getCell).mock.calls).toEqual(expect.arrayContaining([[11, 5], [0, 0]]));
+ expect(vi.mocked(skeleton.worksheet.getCell).mock.calls.every(([row, col]: [number, number]) => (
+ (row === 0 && col === 0) || (row >= 11 && row <= 12 && col === 5)
+ ))).toBe(true);
+ });
+
+ it('draws configured conditional-formatting icons and skips unavailable icons', () => {
+ const ctx = createCtx();
+ const icon = univer.__getInjector().get(ConditionalFormattingIcon);
+ const nativeImage = document.createElement('img');
+ (icon as any)._imageMap.set(`${IIconSetType.threeArrows}_0`, nativeImage);
+
+ const skeleton = createSkeleton({
+ '0,0': {
+ iconSet: {
+ iconType: IIconSetType.threeArrows,
+ iconId: '0',
+ isShowValue: true,
+ },
+ },
+ '0,1': {
+ iconSet: {
+ iconType: IIconSetType.empty,
+ iconId: '0',
+ isShowValue: true,
+ },
+ },
+ '0,2': {
+ iconSet: {
+ iconType: IIconSetType.threeArrows,
+ iconId: '99',
+ isShowValue: true,
+ },
+ },
+ });
+
+ icon.draw(ctx, { scaleX: 1, scaleY: 1 }, skeleton, [
+ { startRow: 0, endRow: 0, startColumn: 0, endColumn: 2 },
+ ]);
+
+ expect(ctx.drawImage).toHaveBeenCalledTimes(1);
+ expect(ctx.drawImage).toHaveBeenCalledWith(nativeImage, 2, 4.5, 15, 15);
+ });
+
+ it('skips icon drawing for missing worksheet and cells too small for the icon', () => {
+ const ctx = createCtx();
+ const icon = univer.__getInjector().get(ConditionalFormattingIcon);
+ const nativeImage = document.createElement('img');
+ (icon as any)._imageMap.set(`${IIconSetType.threeArrows}_0`, nativeImage);
+
+ expect(icon.draw(ctx, { scaleX: 1, scaleY: 1 }, { worksheet: undefined } as any, [])).toBe(false);
+
+ const skeleton = createSkeleton({
+ '0,0': {
+ iconSet: {
+ iconType: IIconSetType.threeArrows,
+ iconId: '0',
+ isShowValue: true,
+ },
+ },
+ }, undefined, undefined, [], { width: 10, height: 10 });
+
+ icon.draw(ctx, { scaleX: 1, scaleY: 1 }, skeleton, [
+ { startRow: 0, endRow: 0, startColumn: 0, endColumn: 0 },
+ ]);
+ expect(ctx.drawImage).not.toHaveBeenCalled();
+ });
+
+ it('skips icon cell visits when a configured rule-range resolver confirms no matching rule', () => {
+ const ctx = createCtx();
+ const skeleton = createSkeleton({});
+ const icon = univer.__getInjector().get(ConditionalFormattingIcon);
+ const resolver = vi.fn(() => []);
+ icon.setRenderRangeResolver(resolver);
+
+ const ranges = [{ startRow: 0, endRow: 0, startColumn: 0, endColumn: 2 }];
+ icon.draw(ctx, { scaleX: 1, scaleY: 1 }, skeleton, ranges);
+
+ expect(resolver).toHaveBeenCalledWith('unit-1', 'sheet-1', ranges);
+ expect(skeleton.worksheet.getCell).not.toHaveBeenCalled();
+ expect(ctx.save).not.toHaveBeenCalled();
+ });
+});
diff --git a/packages/sheets-conditional-formatting/src/render/__tests__/icon.render.spec.ts b/packages/sheets-conditional-formatting/src/render/__tests__/icon.render.spec.ts
new file mode 100644
index 0000000000..ef3f5ddc99
--- /dev/null
+++ b/packages/sheets-conditional-formatting/src/render/__tests__/icon.render.spec.ts
@@ -0,0 +1,199 @@
+/**
+ * Copyright 2023-present DreamNum Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import { Injector } from '@univerjs/core';
+import { Rect, UniverRenderingContext } from '@univerjs/engine-render';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { ConditionalFormattingIcon } from '../icon.render';
+
+function nativeContext(canvas: HTMLCanvasElement): CanvasRenderingContext2D {
+ const smoothing: boolean[] = [];
+ const context = {
+ canvas,
+ imageSmoothingEnabled: true,
+ imageSmoothingQuality: 'low',
+ fillStyle: '#38bdf8',
+ strokeStyle: '#38bdf8',
+ globalAlpha: 1,
+ globalCompositeOperation: 'source-over',
+ shadowColor: 'rgba(0, 0, 0, 0)',
+ getTransform: () => ({ a: 3, b: 0, c: 0, d: 3, e: -162.5, f: 100.5 }),
+ setTransform: vi.fn(),
+ save: vi.fn(() => smoothing.push(context.imageSmoothingEnabled)),
+ restore: vi.fn(() => { context.imageSmoothingEnabled = smoothing.pop()!; }),
+ drawImage: vi.fn(),
+ getLineDash: () => [],
+ setLineDash: vi.fn(),
+ } as unknown as CanvasRenderingContext2D;
+ return context;
+}
+
+describe('conditional formatting icon assets', () => {
+ let injector: Injector;
+ let images: HTMLImageElement[];
+
+ beforeEach(() => {
+ injector = new Injector([[ConditionalFormattingIcon]]);
+ images = [];
+ vi.spyOn(HTMLImageElement.prototype, 'src', 'set').mockImplementation(function (this: HTMLImageElement) {
+ images.push(this);
+ });
+ });
+
+ afterEach(() => {
+ injector.dispose();
+ vi.restoreAllMocks();
+ });
+
+ function createContext(native: CanvasRenderingContext2D): UniverRenderingContext {
+ injector.add([UniverRenderingContext, {
+ useFactory: () => injector.createInstance(UniverRenderingContext, native),
+ }]);
+ return injector.get(UniverRenderingContext);
+ }
+
+ it('invalidates the cached parent when icons finish loading', () => {
+ const extension = injector.get(ConditionalFormattingIcon);
+ injector.add([Rect, { useFactory: () => injector.createInstance(Rect, 'icon-parent', {}) }]);
+ const parent = injector.get(Rect);
+ const dirty = vi.spyOn(parent, 'makeDirty');
+ extension.parent = parent;
+ try {
+ expect(images.length).toBeGreaterThan(0);
+ for (const image of images) {
+ image.dispatchEvent(new Event('load'));
+ }
+ expect(dirty).toHaveBeenCalledTimes(images.length);
+ expect(dirty).toHaveBeenLastCalledWith(true);
+ for (const image of images) {
+ image.dispatchEvent(new Event('load'));
+ }
+ expect(dirty).toHaveBeenCalledTimes(images.length);
+ } finally {
+ extension.dispose();
+ parent.dispose();
+ }
+ });
+
+ it('disconnects pending image loads when disposed', () => {
+ const extension = injector.get(ConditionalFormattingIcon);
+ injector.add([Rect, { useFactory: () => injector.createInstance(Rect, 'disposed-icon-parent', {}) }]);
+ const parent = injector.get(Rect);
+ const dirty = vi.spyOn(parent, 'makeDirty');
+ extension.parent = parent;
+ extension.dispose();
+ try {
+ expect(images.length).toBeGreaterThan(0);
+ for (const image of images) {
+ expect(image.onload).toBeNull();
+ image.dispatchEvent(new Event('load'));
+ }
+ expect(dirty).not.toHaveBeenCalled();
+ } finally {
+ parent.dispose();
+ }
+ });
+
+ it('preserves native resolution and fractional placement, reuses one bitmap and releases it on disposal', () => {
+ const native = nativeContext(document.createElement('canvas'));
+ const context = createContext(native);
+ vi.spyOn(context, 'getSystemType').mockReturnValue('Linux');
+ const contexts = new Map<HTMLCanvasElement, CanvasRenderingContext2D>();
+ vi.spyOn(HTMLCanvasElement.prototype, 'getContext').mockImplementation(function (this: HTMLCanvasElement) {
+ const paint = contexts.get(this) ?? nativeContext(this);
+ contexts.set(this, paint);
+ return paint;
+ });
+ const extension = injector.get(ConditionalFormattingIcon);
+ const image = images[0];
+ try {
+ const draw = Reflect.get(extension, '_drawIcon').bind(extension);
+ draw(context, image, 10, 20);
+ const bitmap = vi.mocked(native.drawImage).mock.calls[0][0] as HTMLCanvasElement;
+ expect([bitmap.width, bitmap.height]).toEqual([50, 50]);
+ expect(native.drawImage).toHaveBeenCalledWith(bitmap, -135, 158);
+ const paint = bitmap.getContext('2d')!;
+ expect(paint.setTransform).toHaveBeenCalledWith(3, 0, 0, 3, 2.5, 2.5);
+ expect(paint.drawImage).toHaveBeenCalledWith(image, 0, 0, 15, 15);
+ draw(context, image, 30, 40);
+ expect(vi.mocked(native.drawImage).mock.calls[1][0]).toBe(bitmap);
+ extension.dispose();
+ expect([bitmap.width, bitmap.height]).toEqual([0, 0]);
+ } finally {
+ extension.dispose();
+ }
+ });
+
+ it.each(['mac', 'printing', 'alpha', 'composition', 'color-space', 'shadow', 'filter', 'rotation', 'large', 'unavailable'])('keeps native icon drawing for %s', (mode) => {
+ const native = nativeContext(document.createElement('canvas'));
+ const context = createContext(native);
+ vi.spyOn(context, 'getSystemType').mockReturnValue(mode === 'mac' ? 'Mac' : 'Linux');
+ if (mode === 'printing') {
+ context.__mode = 'printing';
+ }
+ if (mode === 'alpha') {
+ native.globalAlpha = 0.5;
+ }
+ if (mode === 'composition') {
+ native.globalCompositeOperation = 'destination-out';
+ }
+ if (mode === 'color-space') {
+ Object.defineProperty(native, 'getContextAttributes', { value: () => ({ colorSpace: 'display-p3' }) });
+ }
+ if (mode === 'shadow') {
+ native.shadowBlur = 2;
+ }
+ if (mode === 'filter') {
+ native.filter = 'blur(2px)';
+ }
+ if (mode === 'rotation') {
+ vi.spyOn(native, 'getTransform').mockReturnValue({ a: 1, b: 1, c: 0, d: 1 } as DOMMatrix);
+ }
+ if (mode === 'large') {
+ vi.spyOn(native, 'getTransform').mockReturnValue({ a: 1000, b: 0, c: 0, d: 1000, e: 0, f: 0 } as DOMMatrix);
+ }
+ vi.spyOn(HTMLCanvasElement.prototype, 'getContext').mockImplementation(function (this: HTMLCanvasElement) {
+ return mode === 'unavailable' ? null : nativeContext(this);
+ });
+ const extension = injector.get(ConditionalFormattingIcon);
+ try {
+ Reflect.get(extension, '_drawIcon').call(extension, context, images[0], 10, 20);
+ expect(native.drawImage).toHaveBeenCalledExactlyOnceWith(images[0], 10, 20, 15, 15);
+ } finally {
+ extension.dispose();
+ }
+ });
+
+ it('restores destination state when bitmap submission throws', () => {
+ const native = nativeContext(document.createElement('canvas'));
+ const context = createContext(native);
+ vi.spyOn(context, 'getSystemType').mockReturnValue('Linux');
+ vi.spyOn(HTMLCanvasElement.prototype, 'getContext').mockImplementation(function (this: HTMLCanvasElement) {
+ return nativeContext(this);
+ });
+ vi.mocked(native.drawImage).mockImplementation(() => {
+ throw new Error('Icon submission failed');
+ });
+ const extension = injector.get(ConditionalFormattingIcon);
+ try {
+ expect(() => Reflect.get(extension, '_drawIcon').call(extension, context, images[0], 10, 20)).toThrow('Icon submission failed');
+ expect(native.save).toHaveBeenCalledOnce();
+ expect(native.restore).toHaveBeenCalledOnce();
+ } finally {
+ extension.dispose();
+ }
+ });
+});
diff --git a/packages/sheets-conditional-formatting/src/render/conditional-formatting-raster-cache.ts b/packages/sheets-conditional-formatting/src/render/conditional-formatting-raster-cache.ts
new file mode 100644
index 0000000000..cf0804a6bd
--- /dev/null
+++ b/packages/sheets-conditional-formatting/src/render/conditional-formatting-raster-cache.ts
@@ -0,0 +1,143 @@
+/**
+ * Copyright 2023-present DreamNum Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import { Disposable } from '@univerjs/core';
+import { UniverRenderingContext } from '@univerjs/engine-render';
+
+interface IConditionalFormattingBitmap {
+ canvas: HTMLCanvasElement;
+ pixels: number;
+}
+
+const MAX_ENTRIES = 128;
+const MAX_PIXELS = 512 * 1024;
+const MAX_BITMAP_PIXELS = 128 * 1024;
+
+/** Retain physical pixels without mutating image sources already submitted to the destination. */
+export class ConditionalFormattingRasterCache extends Disposable {
+ private readonly _bitmaps = new Map<string, IConditionalFormattingBitmap>();
+ private _pixels = 0;
+
+ draw(
+ ctx: UniverRenderingContext,
+ x: number,
+ y: number,
+ width: number,
+ height: number,
+ variant: string,
+ draw: (paint: UniverRenderingContext, x: number, y: number) => void,
+ strokeWidth = 0
+ ): void {
+ this.ensureNotDisposed();
+ const native = ctx._context;
+ const m = native?.getTransform();
+ const colorSpace = native?.getContextAttributes?.()?.colorSpace;
+ if (!m || ctx.__mode === 'printing' || typeof document === 'undefined'
+ || m.a !== m.d || m.a <= 0 || m.b || m.c || native.globalAlpha !== 1
+ || native.globalCompositeOperation !== 'source-over' || (colorSpace && colorSpace !== 'srgb')
+ || native.shadowBlur || native.shadowOffsetX || native.shadowOffsetY
+ || !['rgba(0, 0, 0, 0)', 'transparent', '#00000000'].includes(native.shadowColor)
+ || (native.filter && native.filter !== 'none') || width <= 0 || height <= 0
+ || typeof native.fillStyle !== 'string' || typeof native.strokeStyle !== 'string') {
+ draw(ctx, x, y);
+ return;
+ }
+ const px = x * m.a + m.e;
+ const py = y * m.d + m.f;
+ const padding = Math.max(2, Math.ceil(strokeWidth * m.a / 2) + 1);
+ const left = Math.floor(px) - padding;
+ const top = Math.floor(py) - padding;
+ const pixelWidth = Math.ceil(px + width * m.a) - left + padding;
+ const pixelHeight = Math.ceil(py + height * m.d) - top + padding;
+ const pixels = pixelWidth * pixelHeight;
+ if (!Number.isFinite(pixels) || pixels > MAX_BITMAP_PIXELS) {
+ draw(ctx, x, y);
+ return;
+ }
+ const localX = px - left;
+ const localY = py - top;
+ const dash = native.getLineDash();
+ const key = JSON.stringify([
+ variant,
+ width,
+ height,
+ m.a,
+ localX,
+ localY,
+ strokeWidth,
+ native.fillStyle,
+ native.strokeStyle,
+ dash,
+ native.lineDashOffset,
+ native.lineCap,
+ native.lineJoin,
+ native.miterLimit,
+ native.imageSmoothingEnabled,
+ native.imageSmoothingQuality,
+ ]);
+ let bitmap = this._bitmaps.get(key);
+ if (!bitmap) {
+ const canvas = document.createElement('canvas');
+ canvas.width = pixelWidth;
+ canvas.height = pixelHeight;
+ const context = canvas.getContext('2d');
+ if (!context) {
+ draw(ctx, x, y);
+ return;
+ }
+ const paint = new UniverRenderingContext(context);
+ paint.setTransform(m.a, 0, 0, m.d, localX, localY);
+ paint.setLineDash(dash);
+ paint.lineDashOffset = native.lineDashOffset;
+ paint.lineCap = native.lineCap;
+ paint.lineJoin = native.lineJoin;
+ paint.miterLimit = native.miterLimit;
+ paint.imageSmoothingEnabled = native.imageSmoothingEnabled;
+ paint.imageSmoothingQuality = native.imageSmoothingQuality;
+ draw(paint, 0, 0);
+ while (this._bitmaps.size >= MAX_ENTRIES || this._pixels + pixels > MAX_PIXELS) {
+ const oldestKey = this._bitmaps.keys().next().value;
+ if (oldestKey === undefined) {
+ break;
+ }
+ this._pixels -= this._bitmaps.get(oldestKey)!.pixels;
+ // A submitted image may still be consumed by WebKit; release our reference without resizing it.
+ this._bitmaps.delete(oldestKey);
+ }
+ bitmap = { canvas, pixels };
+ this._bitmaps.set(key, bitmap);
+ this._pixels += pixels;
+ }
+ ctx.save();
+ try {
+ ctx.setTransform(1, 0, 0, 1, 0, 0);
+ ctx.imageSmoothingEnabled = false;
+ ctx.drawImage(bitmap.canvas, left, top);
+ } finally {
+ ctx.restore();
+ }
+ }
+
+ override dispose(): void {
+ for (const { canvas } of this._bitmaps.values()) {
+ canvas.width = 0;
+ canvas.height = 0;
+ }
+ this._bitmaps.clear();
+ this._pixels = 0;
+ super.dispose();
+ }
+}
diff --git a/packages/sheets-conditional-formatting/src/render/data-bar.render.ts b/packages/sheets-conditional-formatting/src/render/data-bar.render.ts
index 55fa366691..fd5e08d5b8 100644
--- a/packages/sheets-conditional-formatting/src/render/data-bar.render.ts
+++ b/packages/sheets-conditional-formatting/src/render/data-bar.render.ts
@@ -16,9 +16,15 @@
import type { IRange, IScale } from '@univerjs/core';
import type { SpreadsheetSkeleton, UniverRenderingContext } from '@univerjs/engine-render';
+import { Range, Tools } from '@univerjs/core';
+import {
+ FIX_ONE_PIXEL_BLUR_OFFSET,
+ SheetExtension,
+ SpreadsheetExtensionRegistry,
+} from '@univerjs/engine-render';
import type { IConditionalFormattingRenderRangeResolver, IDataBarCellData } from './type';
-import { Range } from '@univerjs/core';
-import { FIX_ONE_PIXEL_BLUR_OFFSET, SheetExtension, SpreadsheetExtensionRegistry } from '@univerjs/engine-render';
+import { ConditionalFormattingRasterCache } from './conditional-formatting-raster-cache';
+import { resolveRenderRanges } from './resolve-render-ranges';
export const dataBarUKey = 'sheet-conditional-rule-data-bar';
export const defaultDataBarPositiveColor = '#ffbe38';
@@ -34,8 +40,11 @@ const stringifyRange = (range: IRange) => {
};
export class DataBar extends SheetExtension {
+ override readonly viewportCacheReusable = this.constructor === DataBar;
+
private _paddingRightAndLeft = 2;
private _paddingTopAndBottom = 2;
+ private readonly _rasterCache = new ConditionalFormattingRasterCache();
private _renderRangeResolver: IConditionalFormattingRenderRangeResolver | null = null;
override uKey = dataBarUKey;
@@ -59,15 +68,13 @@ export class DataBar extends SheetExtension {
}
const mergeCellRendered = new Set<string>();
const sourceRanges = diffRanges?.length ? diffRanges : [spreadsheetSkeleton.rowColumnSegment];
- const renderRanges = this._renderRangeResolver && worksheet.getMergeData().length === 0
- ? this._renderRangeResolver(worksheet.getUnitId(), worksheet.getSheetId(), sourceRanges) ?? sourceRanges
- : sourceRanges;
+ const renderRanges = resolveRenderRanges(worksheet, sourceRanges, this._renderRangeResolver);
if (!renderRanges.length) {
return;
}
ctx.save();
// ctx.globalCompositeOperation = 'destination-over';
- // eslint-disable-next-line max-lines-per-function
+
renderRanges.forEach((range) => {
Range.foreach(range, (row, col) => {
if (!worksheet.getRowVisible(row) || !worksheet.getColVisible(col)) {
@@ -106,57 +113,62 @@ export class DataBar extends SheetExtension {
const width = borderWidth - this._paddingRightAndLeft * 2;
const height = borderHeight - this._paddingTopAndBottom * 2;
- if (value > 0) {
- // Width less than 1, almost invisible
- const dataBarWidth = Math.max(width * (1 - startPoint / 100) * value / 100, 1);
- const x0 = startX + this._paddingRightAndLeft + (startPoint / 100) * width;
- const y0 = startY + this._paddingTopAndBottom;
+ const positive = value > 0;
+ const dataBarWidth = Math.max(positive
+ ? width * (1 - startPoint / 100) * value / 100
+ : width * startPoint / 100 * Math.abs(value) / 100, 1);
+ const x0 = startX + this._paddingRightAndLeft + (startPoint / 100) * width - (positive ? 0 : dataBarWidth);
+ const y0 = startY + this._paddingTopAndBottom;
+ ctx.fillStyle = color;
+ ctx.strokeStyle = color;
+ const fillColor = ctx.fillStyle;
+ const strokeColor = ctx.strokeStyle;
+ // Destination setters resolve raw colors; bitmap contexts need the already-resolved colors.
+ this._drawAtLocalOrigin(ctx, x0, y0, dataBarWidth, height, (paint, x, y) => {
if (isGradient) {
- const gradient = ctx.createLinearGradient(x0, y0, x0 + dataBarWidth, y0);
- gradient.addColorStop(0, color);
- gradient.addColorStop(1, 'rgb(255 255 255)');
- ctx.fillStyle = gradient;
- ctx.strokeStyle = color;
- ctx.lineWidth = 1;
+ const gradient = paint.createLinearGradient(x, y, x + dataBarWidth, y);
+ gradient.addColorStop(0, positive ? color : 'rgb(255 255 255)');
+ gradient.addColorStop(1, positive ? 'rgb(255 255 255)' : color);
+ paint.fillStyle = gradient;
+ paint.strokeStyle = paint === ctx ? color : strokeColor;
+ paint.lineWidth = 1;
} else {
- ctx.fillStyle = color;
- }
-
- this._drawRectWithRoundedCorner(ctx, x0, y0, dataBarWidth, height, false, true, true, false);
- if (isGradient) {
- ctx.stroke();
+ paint.fillStyle = paint === ctx ? color : fillColor;
}
- } else {
- // Width less than 1, almost invisible
- const dataBarWidth = Math.max(width * startPoint / 100 * Math.abs(value) / 100, 1);
- const x0 = startX + this._paddingRightAndLeft + (startPoint / 100) * width - dataBarWidth;
- const y0 = startY + this._paddingTopAndBottom;
+ this._drawRectWithRoundedCorner(paint, x, y, dataBarWidth, height, !positive, positive, positive, !positive);
if (isGradient) {
- const gradient = ctx.createLinearGradient(x0, y0, x0 + dataBarWidth, y0);
- gradient.addColorStop(0, 'rgb(255 255 255)');
- gradient.addColorStop(1, color);
- ctx.fillStyle = gradient;
- ctx.strokeStyle = color;
- ctx.lineWidth = 1;
- } else {
- ctx.fillStyle = color;
+ paint.stroke();
}
-
- this._drawRectWithRoundedCorner(ctx, x0, y0, dataBarWidth, height, true, false, false, true);
- if (isGradient) {
- ctx.stroke();
- }
- }
+ }, `${positive}:${isGradient}:${this._radius}:${color}`, isGradient ? 1 : 0);
});
});
ctx.restore();
}
override dispose(): void {
+ this._rasterCache.dispose();
this._renderRangeResolver = null;
super.dispose();
}
+ private _drawAtLocalOrigin(
+ ctx: UniverRenderingContext,
+ x: number,
+ y: number,
+ width: number,
+ height: number,
+ draw: (paint: UniverRenderingContext, x: number, y: number) => void,
+ variant = '',
+ strokeWidth = 0
+ ): void {
+ // WebKit's offscreen rounded-corner coverage can differ from native destination drawing.
+ if (typeof navigator !== 'undefined' && (ctx.getBrowserType() === 'Safari' || Tools.isIPhone())) {
+ draw(ctx, x, y);
+ return;
+ }
+ this._rasterCache.draw(ctx, x, y, width, height, variant, draw, strokeWidth);
+ }
+
private _drawRectWithRoundedCorner(ctx: UniverRenderingContext, x: number, y: number, width: number, height: number, topLeftRadius: boolean, topRightRadius: boolean, bottomRightRadius: boolean, bottomLeftRadius: boolean) {
const radius = this._radius;
if (!height || !width) {
diff --git a/packages/sheets-conditional-formatting/src/render/icon.render.ts b/packages/sheets-conditional-formatting/src/render/icon.render.ts
index 79c1b5e18c..c3e7a1c849 100644
--- a/packages/sheets-conditional-formatting/src/render/icon.render.ts
+++ b/packages/sheets-conditional-formatting/src/render/icon.render.ts
@@ -16,10 +16,12 @@
import type { IRange, IScale } from '@univerjs/core';
import type { SpreadsheetSkeleton, UniverRenderingContext } from '@univerjs/engine-render';
-import type { IConditionalFormattingRenderRangeResolver, IIconSetCellData } from './type';
import { Range } from '@univerjs/core';
import { SheetExtension, SpreadsheetExtensionRegistry } from '@univerjs/engine-render';
+import type { IConditionalFormattingRenderRangeResolver, IIconSetCellData } from './type';
import { iconMap, IIconSetType } from '../models/icon-map';
+import { ConditionalFormattingRasterCache } from './conditional-formatting-raster-cache';
+import { resolveRenderRanges } from './resolve-render-ranges';
export const IconUKey = 'sheet-conditional-rule-icon';
const EXTENSION_Z_INDEX = 35;
@@ -32,11 +34,15 @@ const stringifyRange = (range: IRange) => {
};
export class ConditionalFormattingIcon extends SheetExtension {
+ override readonly viewportCacheReusable = this.constructor === ConditionalFormattingIcon;
+
private _paddingRightAndLeft = DEFAULT_PADDING;
private _width = DEFAULT_WIDTH;
private _imageMap: Map<string, HTMLImageElement> = new Map();
+ private readonly _rasterCache = new ConditionalFormattingRasterCache();
+ private readonly _pendingImages = new Set<HTMLImageElement>();
private _renderRangeResolver: IConditionalFormattingRenderRangeResolver | null = null;
override uKey = IconUKey;
@@ -63,9 +69,7 @@ export class ConditionalFormattingIcon extends SheetExtension {
}
const mergeCellRendered = new Set<string>();
const sourceRanges = diffRanges?.length ? diffRanges : [spreadsheetSkeleton.rowColumnSegment];
- const renderRanges = this._renderRangeResolver && worksheet.getMergeData().length === 0
- ? this._renderRangeResolver(worksheet.getUnitId(), worksheet.getSheetId(), sourceRanges) ?? sourceRanges
- : sourceRanges;
+ const renderRanges = resolveRenderRanges(worksheet, sourceRanges, this._renderRangeResolver);
if (!renderRanges.length) {
return;
}
@@ -121,17 +125,33 @@ export class ConditionalFormattingIcon extends SheetExtension {
// Highly centered processing
const y = (borderHeight - this._width) / 2 + startY;
- ctx.drawImage(icon, startX + this._paddingRightAndLeft, y, this._width, this._width);
+ this._drawIcon(ctx, icon, startX + this._paddingRightAndLeft, y);
});
});
ctx.restore();
}
override dispose(): void {
+ this._rasterCache.dispose();
+ for (const image of this._pendingImages) {
+ image.onload = null;
+ }
+ this._pendingImages.clear();
+ this._imageMap.clear();
this._renderRangeResolver = null;
super.dispose();
}
+ private _drawIcon(ctx: UniverRenderingContext, image: HTMLImageElement, x: number, y: number): void {
+ if (!ctx._context || ctx.__mode === 'printing' || ctx.getSystemType() !== 'Linux') {
+ ctx.drawImage(image, x, y, this._width, this._width);
+ return;
+ }
+ this._rasterCache.draw(ctx, x, y, this._width, this._width, image.src, (paint, left, top) => {
+ paint.drawImage(image, left, top, this._width, this._width);
+ });
+ }
+
private _init() {
for (const type in iconMap) {
const list = iconMap[type as IIconSetType];
@@ -139,8 +159,12 @@ export class ConditionalFormattingIcon extends SheetExtension {
const key = this._createKey(type as IIconSetType, String(index));
const image = new Image();
image.onload = () => {
+ image.onload = null;
+ this._pendingImages.delete(image);
this._imageMap.set(key, image);
+ this.parent?.makeDirty(true);
};
+ this._pendingImages.add(image);
image.src = base64;
});
}
diff --git a/packages/sheets-conditional-formatting/src/render/resolve-render-ranges.ts b/packages/sheets-conditional-formatting/src/render/resolve-render-ranges.ts
new file mode 100644
index 0000000000..4fd498096f
--- /dev/null
+++ b/packages/sheets-conditional-formatting/src/render/resolve-render-ranges.ts
@@ -0,0 +1,64 @@
+/**
+ * Copyright 2023-present DreamNum Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import type { IRange, Worksheet } from '@univerjs/core';
+import { getIntersectRange, Rectangle } from '@univerjs/core';
+import type { IConditionalFormattingRenderRangeResolver } from './type';
+
+export function resolveRenderRanges(
+ worksheet: Worksheet,
+ sourceRanges: IRange[],
+ resolver: IConditionalFormattingRenderRangeResolver | null
+): IRange[] {
+ if (!resolver) {
+ return sourceRanges;
+ }
+ const mergedRanges = worksheet.getMergeData().length
+ ? sourceRanges.flatMap((range) => worksheet.getMergedCellRange(
+ range.startRow,
+ range.startColumn,
+ range.endRow,
+ range.endColumn
+ ))
+ : [];
+ // A visible merged cell can obtain its formatting from an offscreen anchor.
+ const queryRanges = mergedRanges.length
+ ? [...sourceRanges, ...mergedRanges.map((range) => ({
+ startRow: range.startRow,
+ endRow: range.startRow,
+ startColumn: range.startColumn,
+ endColumn: range.startColumn,
+ }))]
+ : sourceRanges;
+ const resolved = resolver(worksheet.getUnitId(), worksheet.getSheetId(), queryRanges);
+ if (!resolved) {
+ return sourceRanges;
+ }
+ if (!mergedRanges.length || !resolved.length) {
+ return resolved;
+ }
+ const formattedMerges = mergedRanges.filter((merge) => resolved.some((range) => Rectangle.intersects(merge, range)));
+ const clipped: IRange[] = [];
+ for (const source of sourceRanges) {
+ for (const range of [...resolved, ...formattedMerges]) {
+ const intersection = getIntersectRange(source, range);
+ if (intersection) {
+ clipped.push(intersection);
+ }
+ }
+ }
+ return clipped.length > 1 ? Rectangle.mergeRanges(clipped) : clipped;
+}
diff --git a/packages/sheets-drawing-ui/src/services/__tests__/canvas-float-dom-manager.service.spec.ts b/packages/sheets-drawing-ui/src/services/__tests__/canvas-float-dom-manager.service.spec.ts
index 19dc5e7a76..50d636e7f7 100644
--- a/packages/sheets-drawing-ui/src/services/__tests__/canvas-float-dom-manager.service.spec.ts
+++ b/packages/sheets-drawing-ui/src/services/__tests__/canvas-float-dom-manager.service.spec.ts
@@ -1032,6 +1032,38 @@ describe('SheetCanvasFloatDomManagerService', () => {
});
});
+ it.each([0.5, 1, 2])('clips float DOM content to scaled sheet headers at zoom %s', (scale) => {
+ const fixture = setup();
+ disposables.push(fixture);
+ vi.spyOn(fixture.scene, 'getAncestorScale').mockReturnValue({ scaleX: scale, scaleY: scale });
+
+ const bounds = { left: 12, right: 230, top: 10, bottom: 180 };
+ expect(transformBound2DOMBound(bounds, fixture.scene, fixture.skeleton, fixture.worksheet)).toEqual({
+ left: 46 * scale,
+ right: 200 * scale,
+ top: 28 * scale,
+ bottom: 162 * scale,
+ absolute: { left: false, top: false },
+ });
+ });
+
+ it('updates drawing header clipping after zoom changes without recreating the drawing', () => {
+ const fixture = setup();
+ disposables.push(fixture);
+ fixture.manager.addFloatDomToRange({ startRow: 0, endRow: 0, startColumn: 0, endColumn: 0 }, {
+ componentKey: 'RangeCard',
+ initPosition: { startX: 0, startY: 0, endX: 0, endY: 0 },
+ allowTransform: true,
+ }, { width: 160, height: 100 }, 'zoom-card');
+ const info = fixture.manager.getFloatDomInfo('zoom-card')!;
+ vi.spyOn(fixture.scene, 'getAncestorScale').mockReturnValue({ scaleX: 0.5, scaleY: 0.5 });
+
+ const layout = calcSheetFloatDomPosition(info.rect, fixture.scene, fixture.skeleton, fixture.worksheet, info);
+
+ expect(layout.startX).toBe(23);
+ expect(layout.startY).toBe(14);
+ });
+
it('keeps float dom bounds stable when the main viewport is unavailable', () => {
const fixture = setup();
disposables.push(fixture);
@@ -1140,6 +1172,7 @@ describe('SheetCanvasFloatDomManagerService', () => {
fixture.manager.addFloatDomToColumnHeader(1, options, { width: 100, height: 40 }, 'wheel-card');
}
const layer = findFloatDom(fixture.get(CanvasFloatDomService), 'wheel-card')!;
+ expect(layer.preventBrowserZoom).toBe(true);
const unconsumed = new WheelEvent('wheel', { deltaY: 1.25, cancelable: true });
layer.onWheel(unconsumed);
expect(unconsumed.defaultPrevented).toBe(false);
diff --git a/packages/sheets-drawing-ui/src/services/canvas-float-dom-manager.service.ts b/packages/sheets-drawing-ui/src/services/canvas-float-dom-manager.service.ts
index 785e426072..20c088c00b 100644
--- a/packages/sheets-drawing-ui/src/services/canvas-float-dom-manager.service.ts
+++ b/packages/sheets-drawing-ui/src/services/canvas-float-dom-manager.service.ts
@@ -612,8 +612,8 @@ export function transformBound2DOMBound(posOfFloatObject: IBoundRectNoAngle, sce
const { boundsOfViewArea: specBoundsOfViewArea, scrollDirectionResponse } = floatDomInfo || {};
const { rowHeaderWidth, columnHeaderHeight } = skeleton;
const boundsOfViewArea = {
- top: skipBoundsOfViewArea ? 0 : columnHeaderHeight,
- left: skipBoundsOfViewArea ? 0 : rowHeaderWidth,
+ top: skipBoundsOfViewArea ? 0 : columnHeaderHeight * scaleY,
+ left: skipBoundsOfViewArea ? 0 : rowHeaderWidth * scaleX,
};
if (specBoundsOfViewArea) {
if (Tools.isDefine(boundsOfViewArea.top)) {
@@ -1445,6 +1445,7 @@ export class SheetCanvasFloatDomManagerService extends Disposable {
domId,
componentKey: floatDomParam.componentKey,
eventPassThrough: shouldPassThroughFloatDomRuntimeEvents(floatDomParam, 'inactive'),
+ preventBrowserZoom: true,
preserveOnFocusChange: shouldPreserveFloatDomOnFocusChange(floatDomParam),
onPointerDown: (evt) => {
if (shouldForwardSheetHostedEmbedFloatDomEvent(floatDomParam, evt)) {
@@ -2142,20 +2143,9 @@ export class SheetCanvasFloatDomManagerService extends Disposable {
}
const disposableCollection = new DisposableCollection();
- const viewMain = scene.getMainViewport();
- const { rowHeaderWidth, columnHeaderHeight } = skeletonParam.skeleton;
-
- const boundsOfViewArea: IBoundRectNoAngle = {
- top: columnHeaderHeight,
- left: rowHeaderWidth,
- bottom: viewMain.bottom,
- right: viewMain.right,
- };
-
const floatDomInfo = {
dispose: disposableCollection,
rect: domRect,
- boundsOfViewArea,
domAnchor,
unitId,
subUnitId,
@@ -2171,6 +2161,7 @@ export class SheetCanvasFloatDomManagerService extends Disposable {
let floatDomCfg: IFloatDom = {
position$,
id: drawingId,
+ preventBrowserZoom: true,
componentKey: floatDomParam.componentKey,
onPointerDown: () => { },
onPointerMove: () => { },
@@ -2414,6 +2405,7 @@ export class SheetCanvasFloatDomManagerService extends Disposable {
let floatDomCfg: IFloatDom = {
position$,
id: drawingId,
+ preventBrowserZoom: true,
componentKey: floatDomParam.componentKey,
onPointerDown: () => { },
onPointerMove: () => { },
diff --git a/packages/sheets-drawing-ui/src/views/background/worksheet-background-image.extension.ts b/packages/sheets-drawing-ui/src/views/background/worksheet-background-image.extension.ts
index 4ea006c452..eb94ff3670 100644
--- a/packages/sheets-drawing-ui/src/views/background/worksheet-background-image.extension.ts
+++ b/packages/sheets-drawing-ui/src/views/background/worksheet-background-image.extension.ts
@@ -22,6 +22,8 @@ import { SHEET_EXTENSION_TYPE, SheetExtension } from '@univerjs/engine-render';
export const WORKSHEET_BACKGROUND_IMAGE_EXTENSION_KEY = 'WorksheetBackgroundImageExtension';
export class WorksheetBackgroundImageExtension extends SheetExtension {
+ override readonly viewportCacheReusable = this.constructor === WorksheetBackgroundImageExtension;
+
override uKey = WORKSHEET_BACKGROUND_IMAGE_EXTENSION_KEY;
override type = SHEET_EXTENSION_TYPE.BACKGROUND;
diff --git a/packages/sheets-note/src/models/__tests__/sheets-note.model.spec.ts b/packages/sheets-note/src/models/__tests__/sheets-note.model.spec.ts
index 0949fabd9a..899a61a782 100644
--- a/packages/sheets-note/src/models/__tests__/sheets-note.model.spec.ts
+++ b/packages/sheets-note/src/models/__tests__/sheets-note.model.spec.ts
@@ -14,10 +14,10 @@
* limitations under the License.
*/
-import type { ISheetNote } from '../sheets-note.model';
import { Injector } from '@univerjs/core';
import { filter, firstValueFrom, take, toArray } from 'rxjs';
-import { beforeEach, describe, expect, it } from 'vitest';
+import { afterEach, beforeEach, describe, expect, it } from 'vitest';
+import type { ISheetNote } from '../sheets-note.model';
import { SheetsNoteModel } from '../sheets-note.model';
describe('SheetsNoteModel', () => {
@@ -34,6 +34,10 @@ describe('SheetsNoteModel', () => {
model = injector.get(SheetsNoteModel);
});
+ afterEach(() => {
+ injector.dispose();
+ });
+
it('updates a note and emits change events', async () => {
const noteInput: ISheetNote = {
id: 'note-1',
@@ -157,4 +161,136 @@ describe('SheetsNoteModel', () => {
expect(emitted).toBe(false);
subscription.unsubscribe();
});
+
+ it('does not rescan unrelated notes on repeated position reads', () => {
+ let rowReads = 0;
+ for (let row = 0; row < 1000; row++) {
+ model.updateNote(unitId, subUnitId, row, 2, { id: `note-${row}`, note: `note ${row}` });
+ const note = model.getNote(unitId, subUnitId, { noteId: `note-${row}` })!;
+ Object.defineProperty(note, 'row', {
+ enumerable: true,
+ get: () => {
+ rowReads++;
+ return row;
+ },
+ });
+ }
+
+ expect(model.getNote(unitId, subUnitId, { row: 999, col: 2 })?.id).toBe('note-999');
+ rowReads = 0;
+ for (let row = 1000; row < 1020; row++) {
+ expect(model.getNote(unitId, subUnitId, { row, col: 2 })).toBeUndefined();
+ }
+ expect(model.getNote(unitId, subUnitId, { row: 999, col: 2 })?.id).toBe('note-999');
+ expect(rowReads).toBeLessThanOrEqual(1);
+ });
+
+ it('refreshes indexed notes before synchronous change subscribers run', () => {
+ model.updateNote(unitId, subUnitId, 0, 0, { id: 'first', note: 'before', show: false });
+ expect(model.getNote(unitId, subUnitId, { row: 0, col: 0 })?.note).toBe('before');
+ const seen: string[] = [];
+ const subscription = model.change$.subscribe(({ newNote }) => {
+ if (newNote) {
+ expect(model.getNote(unitId, subUnitId, { row: newNote.row, col: newNote.col })).toBe(newNote);
+ seen.push(newNote.note);
+ } else {
+ expect(model.getNote(unitId, subUnitId, { row: 1, col: 2 })).toBeUndefined();
+ seen.push('removed');
+ }
+ });
+
+ model.updateNote(unitId, subUnitId, 0, 0, { id: 'first', note: 'after', show: false });
+ model.toggleNotePopup(unitId, subUnitId, { row: 0, col: 0 });
+ expect(model.getNote(unitId, subUnitId, { row: 0, col: 0 })?.show).toBe(true);
+ model.updateNotePosition(unitId, subUnitId, { noteId: 'first', newRow: 1, newCol: 2 });
+ expect(model.getNote(unitId, subUnitId, { row: 0, col: 0 })).toBeUndefined();
+ model.removeNote(unitId, subUnitId, { row: 1, col: 2 });
+ expect(seen).toEqual(['after', 'after', 'after', 'removed']);
+ subscription.unsubscribe();
+ });
+
+ it('preserves first inserted note precedence when positions collide', () => {
+ model.updateNote(unitId, subUnitId, 0, 0, { id: 'first', note: 'first' });
+ model.updateNote(unitId, subUnitId, 1, 1, { id: 'second', note: 'second' });
+ expect(model.getNote(unitId, subUnitId, { row: 0, col: 0 })?.id).toBe('first');
+
+ model.updateNotePosition(unitId, subUnitId, { noteId: 'second', newRow: 0, newCol: 0 });
+ expect(model.getNote(unitId, subUnitId, { row: 0, col: 0 })?.id).toBe('first');
+ model.updateNotePosition(unitId, subUnitId, { noteId: 'first', newRow: 2, newCol: 2 });
+ expect(model.getNote(unitId, subUnitId, { row: 0, col: 0 })?.id).toBe('second');
+ model.updateNote(unitId, subUnitId, 0, 0, { id: 'first', note: 'first replaced' });
+ expect(model.getNote(unitId, subUnitId, { row: 2, col: 2 })).toBeUndefined();
+ expect(model.getNote(unitId, subUnitId, { row: 0, col: 0 })?.id).toBe('first');
+ model.removeNote(unitId, subUnitId, { noteId: 'first' });
+ expect(model.getNote(unitId, subUnitId, { row: 0, col: 0 })?.id).toBe('second');
+ });
+
+ it('matches insertion-order lookup throughout interleaved note mutations', () => {
+ for (let step = 0; step < 120; step++) {
+ const row = step % 5;
+ const col = Math.floor(step / 5) % 4;
+ const noteId = `note-${step % 13}`;
+ switch (step % 6) {
+ case 0:
+ model.updateNote(unitId, subUnitId, row, col, { id: noteId, note: `note ${step}` });
+ break;
+ case 1:
+ model.updateNote(unitId, subUnitId, row, col, { note: `new ${step}` });
+ break;
+ case 2:
+ model.updateNotePosition(unitId, subUnitId, { noteId, newRow: row, newCol: col });
+ break;
+ case 3:
+ model.toggleNotePopup(unitId, subUnitId, { row, col });
+ break;
+ case 4:
+ model.removeNote(unitId, subUnitId, { noteId });
+ break;
+ case 5:
+ model.removeNote(unitId, subUnitId, { row, col });
+ break;
+ }
+
+ const notes = Array.from(model.getSheetNotes(unitId, subUnitId)?.values() ?? []);
+ for (let r = 0; r < 5; r++) {
+ for (let c = 0; c < 4; c++) {
+ expect(model.getNote(unitId, subUnitId, { row: r, col: c })).toBe(
+ notes.find((note) => note.row === r && note.col === c)
+ );
+ }
+ }
+ }
+ });
+
+ it('isolates indexes across sheets and releases unit notes before reloading', () => {
+ for (const [unit, sheet, id] of [[unitId, subUnitId, 'first'], [unitId, 'other-sheet', 'second'], ['other-unit', subUnitId, 'third']]) {
+ model.updateNote(unit, sheet, 1, 2, { id, note: id });
+ expect(model.getNote(unit, sheet, { row: 1, col: 2 })?.id).toBe(id);
+ }
+ model.deleteUnitNotes(unitId);
+ expect(model.getUnitNotes(unitId)).toBeUndefined();
+ expect(model.getNote(unitId, subUnitId, { row: 1, col: 2 })).toBeUndefined();
+ expect(model.getNote(unitId, 'other-sheet', { row: 1, col: 2 })).toBeUndefined();
+ expect(model.getNote('other-unit', subUnitId, { row: 1, col: 2 })?.id).toBe('third');
+ model.updateNote(unitId, subUnitId, 1, 2, { id: 'reloaded', note: 'new' });
+ expect(model.getNote(unitId, subUnitId, { row: 1, col: 2 })?.id).toBe('reloaded');
+ });
+
+ it('clears note references and completes change streams on disposal', () => {
+ model.updateNote(unitId, subUnitId, 1, 2, { id: 'note', note: 'note' });
+ expect(model.getNote(unitId, subUnitId, { row: 1, col: 2 })?.id).toBe('note');
+ let completed = false;
+ const subscription = model.change$.subscribe({
+ complete: () => {
+ completed = true;
+ },
+ });
+
+ model.dispose();
+ expect(model.getNotes().size).toBe(0);
+ expect(model.getUnitNotes(unitId)).toBeUndefined();
+ expect(completed).toBe(true);
+ expect(subscription.closed).toBe(true);
+ model.dispose();
+ });
});
diff --git a/packages/sheets-note/src/models/sheets-note.model.ts b/packages/sheets-note/src/models/sheets-note.model.ts
index c081e06071..204d6f487c 100644
--- a/packages/sheets-note/src/models/sheets-note.model.ts
+++ b/packages/sheets-note/src/models/sheets-note.model.ts
@@ -16,7 +16,7 @@
import type { Nullable } from '@univerjs/core';
import type { ISheetLocationBase } from '@univerjs/sheets';
-import { Disposable, generateRandomId } from '@univerjs/core';
+import { Disposable, generateRandomId, ObjectMatrix } from '@univerjs/core';
import { filter, map, Subject } from 'rxjs';
export interface ISheetNote {
@@ -44,9 +44,17 @@ export type ISheetNoteChange = {
export class SheetsNoteModel extends Disposable {
private _notesMap: Map<string, Map<string, Map<string, ISheetNote>>> = new Map();
+ private _notePositionCache = new WeakMap<Map<string, ISheetNote>, ObjectMatrix<ISheetNote>>();
private readonly _change$ = new Subject<ISheetNoteChange>();
readonly change$ = this._change$.asObservable();
+ override dispose(): void {
+ this._notePositionCache = new WeakMap();
+ this._notesMap.clear();
+ this._change$.complete();
+ super.dispose();
+ }
+
private _ensureNotesMap(unitId: string, subUnitId: string): Map<string, ISheetNote> {
let unitMap = this._notesMap.get(unitId);
if (!unitMap) {
@@ -65,12 +73,20 @@ export class SheetsNoteModel extends Disposable {
private _getNoteByPosition(unitId: string, subUnitId: string, row: number, col: number): Nullable<ISheetNote> {
const subUnitMap = this._ensureNotesMap(unitId, subUnitId);
-
- for (const [_, note] of subUnitMap) {
- if (note.row === row && note.col === col) {
- return note;
+ let positions = this._notePositionCache.get(subUnitMap);
+ if (!positions) {
+ positions = new ObjectMatrix<ISheetNote>();
+ for (const note of subUnitMap.values()) {
+ // Preserve the ID map's first-insertion precedence when notes share a position.
+ if (!positions.getValue(note.row, note.col)) {
+ positions.setValue(note.row, note.col, note);
+ }
}
+ this._notePositionCache.set(subUnitMap, positions);
}
+
+ const note = positions.getValue(row, col);
+ return note?.row === row && note.col === col ? note : undefined;
}
private _getNoteById(unitId: string, subUnitId: string, id: string): Nullable<ISheetNote> {
@@ -132,6 +148,7 @@ export class SheetsNoteModel extends Disposable {
col,
} as ISheetNote;
subUnitMap.set(newNote.id, newNote);
+ this._notePositionCache.delete(subUnitMap);
this._change$.next({ unitId, subUnitId, oldNote, type: 'update', newNote, silent });
}
@@ -146,6 +163,7 @@ export class SheetsNoteModel extends Disposable {
const subUnitMap = this._ensureNotesMap(unitId, subUnitId);
subUnitMap.delete(oldNote.id);
+ this._notePositionCache.delete(subUnitMap);
this._change$.next({ unitId, subUnitId, oldNote, type: 'update', newNote: null, silent });
}
@@ -161,6 +179,7 @@ export class SheetsNoteModel extends Disposable {
const subUnitMap = this._ensureNotesMap(unitId, subUnitId);
const newNote = { ...oldNote, show: !oldNote.show };
subUnitMap.set(newNote.id, newNote);
+ this._notePositionCache.delete(subUnitMap);
this._change$.next({ unitId, subUnitId, oldNote, type: 'update', newNote, silent });
}
@@ -176,6 +195,7 @@ export class SheetsNoteModel extends Disposable {
const subUnitMap = this._ensureNotesMap(unitId, subUnitId);
const newNote = { ...oldNote, row: newRow, col: newCol };
subUnitMap.set(newNote.id, newNote);
+ this._notePositionCache.delete(subUnitMap);
this._change$.next({ unitId, subUnitId, oldNote, type: 'ref', newNote, silent });
}
@@ -201,6 +221,7 @@ export class SheetsNoteModel extends Disposable {
}
deleteUnitNotes(unitId: string): void {
+ this._notesMap.get(unitId)?.forEach((notes) => this._notePositionCache.delete(notes));
this._notesMap.delete(unitId);
}
}
diff --git a/packages/sheets-table-ui/src/controllers/__tests__/sheet-table-controls-render.controller.spec.ts b/packages/sheets-table-ui/src/controllers/__tests__/sheet-table-controls-render.controller.spec.ts
index 2c5aee2367..4b60831625 100644
--- a/packages/sheets-table-ui/src/controllers/__tests__/sheet-table-controls-render.controller.spec.ts
+++ b/packages/sheets-table-ui/src/controllers/__tests__/sheet-table-controls-render.controller.spec.ts
@@ -47,11 +47,19 @@ import {
WorksheetProtectionPointModel,
WorksheetProtectionRuleModel,
} from '@univerjs/sheets';
-import { DeleteSheetTableCommand, DeleteSheetTableMutation, SheetTableService, TableManager } from '@univerjs/sheets-table';
+import {
+ DeleteSheetTableCommand,
+ DeleteSheetTableMutation,
+ SheetTableService,
+ TableManager,
+} from '@univerjs/sheets-table';
import {
ISheetSelectionRenderService,
MoveSelectionCommand,
SelectAllCommand,
+ SetScrollOperation,
+ SetScrollRelativeCommand,
+ SetZoomRatioOperation,
SheetCanvasPopManagerService,
SheetSkeletonManagerService,
} from '@univerjs/sheets-ui';
@@ -153,6 +161,84 @@ function createTestBed(hasSkeleton = true, controllerType = SheetTableControlsRe
}
describe('SheetTableControlsRenderController', () => {
+ it('skips empty-table scroll refreshes while preserving zoom, mutation and table-add refreshes', () => {
+ const { injector, scene, addTable } = createTestBed();
+ injector.get(SheetTableControlsRenderController);
+ const shape = scene.getObject('SheetTableControlsShape') as SheetTableControlsShape;
+ const sceneMakeDirty = vi.spyOn(scene, 'makeDirty');
+ const commands = injector.get(ICommandService);
+ for (const command of [SetScrollRelativeCommand, SetScrollOperation]) {
+ commands.registerCommand({ id: command.id, type: command.type, handler: () => true });
+ expect(commands.syncExecuteCommand(command.id)).toBe(true);
+ }
+ expect(shape.hasItems()).toBe(false);
+ expect(sceneMakeDirty).not.toHaveBeenCalled();
+
+ for (const command of [
+ { id: SetZoomRatioOperation.id, type: CommandType.OPERATION },
+ { id: 'sheet.mutation.unknown-table-notification', type: CommandType.MUTATION },
+ ]) {
+ commands.registerCommand({ ...command, handler: () => true });
+ sceneMakeDirty.mockClear();
+ expect(commands.syncExecuteCommand(command.id)).toBe(true);
+ expect(sceneMakeDirty).toHaveBeenCalledOnce();
+ }
+
+ sceneMakeDirty.mockClear();
+ addTable();
+ expect(shape.hasItems()).toBe(true);
+ expect(sceneMakeDirty).toHaveBeenCalledOnce();
+ });
+
+ it('refreshes existing tables on scroll even when their controls have no items yet', () => {
+ const { injector, scene, addTable } = createTestBed();
+ addTable();
+ injector.get(SheetTableControlsRenderController);
+ const shape = scene.getObject('SheetTableControlsShape') as SheetTableControlsShape;
+ const sceneMakeDirty = vi.spyOn(scene, 'makeDirty');
+ const commands = injector.get(ICommandService);
+ for (const command of [SetScrollRelativeCommand, SetScrollOperation]) {
+ shape.setItems([]);
+ sceneMakeDirty.mockClear();
+ commands.registerCommand({ id: command.id, type: command.type, handler: () => true });
+ expect(commands.syncExecuteCommand(command.id)).toBe(true);
+ expect(shape.hasItems()).toBe(true);
+ expect(sceneMakeDirty).toHaveBeenCalledOnce();
+ }
+ });
+
+ it('restores a removed top table gap before returning to empty-table scroll reuse', () => {
+ const { injector, scene } = createTestBed();
+ const skeleton = injector.get(SheetSkeletonManagerService).getCurrentSkeleton()!;
+ skeleton.setGapConfig({ rowGaps: { 0: { size: 12 } } });
+ const tables = injector.get(TableManager);
+ tables.addTable('unit-1', 'sheet-1', 'Top table', {
+ startRow: 0,
+ endRow: 3,
+ startColumn: 0,
+ endColumn: 1,
+ }, ['Name', 'Amount'], 'top-table');
+ const commands = injector.get(ICommandService);
+ commands.registerCommand({ id: SetScrollOperation.id, type: CommandType.OPERATION, handler: () => true });
+ const removal = tables.tableDelete$.subscribe(() => {
+ // A scroll can arrive after the model removes a table but before the controls receive that notification.
+ shape.setItems([]);
+ expect(commands.syncExecuteCommand(SetScrollOperation.id)).toBe(true);
+ expect(skeleton.gapConfig.rowGaps?.[0]?.size).toBe(12);
+ });
+ disposables.push({ dispose: () => removal.unsubscribe() });
+ injector.get(SheetTableControlsRenderController);
+ const shape = scene.getObject('SheetTableControlsShape') as SheetTableControlsShape;
+ expect(skeleton.gapConfig.rowGaps?.[0]?.size).toBeGreaterThan(12);
+
+ tables.deleteTable('unit-1', 'top-table');
+ expect(skeleton.gapConfig.rowGaps?.[0]?.size).toBe(12);
+ const sceneMakeDirty = vi.spyOn(scene, 'makeDirty');
+ expect(commands.syncExecuteCommand(SetScrollOperation.id)).toBe(true);
+ expect(sceneMakeDirty).not.toHaveBeenCalled();
+ expect(skeleton.gapConfig.rowGaps?.[0]?.size).toBe(12);
+ });
+
it('keeps sheet caches for selection refreshes and invalidates them for table refreshes', () => {
const { injector, scene, addTable } = createTestBed();
injector.get(SheetTableControlsRenderController);
diff --git a/packages/sheets-table-ui/src/controllers/sheet-table-controls-render.controller.ts b/packages/sheets-table-ui/src/controllers/sheet-table-controls-render.controller.ts
index 436e2f0412..0a01ad9f38 100644
--- a/packages/sheets-table-ui/src/controllers/sheet-table-controls-render.controller.ts
+++ b/packages/sheets-table-ui/src/controllers/sheet-table-controls-render.controller.ts
@@ -56,6 +56,7 @@ import {
MoveSelectionEnterAndTabCommand,
SelectAllCommand,
SetScrollOperation,
+ SetScrollRelativeCommand,
SetZoomRatioOperation,
SHEET_VIEW_KEY,
SheetCanvasPopManagerService,
@@ -170,6 +171,16 @@ export class SheetTableControlsRenderController extends Disposable implements IR
return false;
}
+ if (command.id === SetScrollRelativeCommand.id || command.id === SetScrollOperation.id) {
+ const worksheet = this._context.unit.getActiveSheet();
+ const skeleton = this._sheetSkeletonManagerService.getCurrentSkeleton();
+ this._closeFloatingControls();
+ if (worksheet && skeleton && !this._shape.hasItems() && !this._topGapBaseBySkeleton.has(skeleton) &&
+ this._tableManager.getTablesBySubunitId(this._context.unit.getUnitId(), worksheet.getSheetId()).length === 0) {
+ return false;
+ }
+ }
+
if (command.type === CommandType.OPERATION && TABLE_RENDER_REFRESH_COMMANDS.has(command.id)) {
this._closeFloatingControls();
return true;
diff --git a/packages/sheets-table-ui/src/views/widgets/table-controls.shape.ts b/packages/sheets-table-ui/src/views/widgets/table-controls.shape.ts
index 2267afbd1d..585c5c71c8 100644
--- a/packages/sheets-table-ui/src/views/widgets/table-controls.shape.ts
+++ b/packages/sheets-table-ui/src/views/widgets/table-controls.shape.ts
@@ -15,8 +15,8 @@
*/
import type { IShapeProps, SpreadsheetSkeleton, UniverRenderingContext, Vector2 } from '@univerjs/engine-render';
-import type { ITableControlHitRegion } from './table-controls-util';
import { DEFAULT_FONTFACE_PLANE, Shape } from '@univerjs/engine-render';
+import type { ITableControlHitRegion } from './table-controls-util';
import {
buildCenteredPlusSegments,
hitTestTableControl,
@@ -61,6 +61,10 @@ export class SheetTableControlsShape extends Shape<IShapeProps> {
});
}
+ hasItems(): boolean {
+ return this._items.length > 0;
+ }
+
setItems(items: ITableControlRenderItem[]): void {
this._items = items;
this.makeDirty(true);
diff --git a/packages/sheets-ui/src/controllers/render-controllers/__tests__/render-test-bed.ts b/packages/sheets-ui/src/controllers/render-controllers/__tests__/render-test-bed.ts
index b6fe800985..23d0903b90 100644
--- a/packages/sheets-ui/src/controllers/render-controllers/__tests__/render-test-bed.ts
+++ b/packages/sheets-ui/src/controllers/render-controllers/__tests__/render-test-bed.ts
@@ -206,6 +206,7 @@ export interface IFakeScene {
makeDirtyForScrolling(): void;
isDirty(): boolean;
isScrollRenderPending(): boolean;
+ isViewportCacheReusePending(): boolean;
getLayers(): Array<{ getObjectsByOrder(): Array<{ isDirty(): boolean }> }>;
getViewport(key: unknown): IFakeViewport | null;
getMainViewport(): IFakeViewport;
@@ -266,6 +267,7 @@ export function createFakeScene(
makeDirtyForScrolling: () => { },
isDirty: () => false,
isScrollRenderPending: () => false,
+ isViewportCacheReusePending: () => false,
getLayers: () => Array.from(layers.values()) as Array<{ getObjectsByOrder(): Array<{ isDirty(): boolean }> }>,
getViewport: (key) => viewportMap.get(key) ?? null,
getMainViewport: () => viewportMap.get(SHEET_VIEWPORT_KEY.VIEW_MAIN)!,
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 7e4b62fefb..c8f07d9019 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
@@ -15,11 +15,12 @@
*/
import type { IWheelEvent } from '@univerjs/engine-render';
-import { Direction, FOCUSING_SHEET, ICommandService } from '@univerjs/core';
+import { CommandType, Direction, FOCUSING_SHEET, ICommandService, IContextService } from '@univerjs/core';
import { IRenderManagerService, RENDER_CLASS_TYPE, SHEET_VIEWPORT_KEY } from '@univerjs/engine-render';
import { SetSelectionsOperation } from '@univerjs/sheets';
import { Subject } from 'rxjs';
import { afterEach, beforeEach, describe, expect, it, onTestFinished, vi } from 'vitest';
+import type { IFakeEngine } from './render-test-bed';
import { ScrollCommand, SetScrollRelativeCommand } from '../../../commands/commands/set-scroll.command';
import { ExpandSelectionCommand } from '../../../commands/commands/set-selection.command';
import { SetScrollOperation } from '../../../commands/operations/scroll.operation';
@@ -53,12 +54,47 @@ function createScrollManagerServiceMock() {
let pendingAnimationFrames: FrameRequestCallback[] = [];
-function flushWheelFrame() {
+function flushWheelFrame(scene: ReturnType<typeof createRenderTestBed>['scene']) {
+ const engine = scene.getEngine() as IFakeEngine;
+ if (engine.beginFrame$) {
+ engine.runRenderLoop(() => {});
+ return;
+ }
const callback = pendingAnimationFrames.shift();
expect(callback).toBeDefined();
callback!(performance.now());
}
+function createRealScrollFixture() {
+ const fixture = createChartRenderTestBed([
+ [SheetScrollManagerService],
+ [SheetsScrollRenderController],
+ ], false, { rowCount: 1000, columnCount: 100, zoomRatio: 1, freeze: { startRow: 0, startColumn: 0, xSplit: 0, ySplit: 0 } });
+ for (const command of [ScrollCommand, SetScrollRelativeCommand, SetScrollOperation]) {
+ fixture.commands.registerCommand(command);
+ }
+ const execute = vi.spyOn(fixture.commands, 'executeCommand');
+ const wheel = (deltaX: number, deltaY: number) => fixture.render.scene.onMouseWheel$.emitEvent({
+ deltaX,
+ deltaY,
+ ctrlKey: false,
+ shiftKey: false,
+ preventDefault: () => {},
+ } as IWheelEvent);
+ const frame = async () => {
+ fixture.render.engine._beginFrame(performance.now());
+ await Promise.all(execute.mock.results.filter((result) => result.type === 'return').map((result) => result.value));
+ };
+ return {
+ ...fixture,
+ controller: fixture.render.with(SheetsScrollRenderController),
+ viewport: fixture.render.scene.getMainViewport(),
+ execute,
+ wheel,
+ frame,
+ };
+}
+
describe('SheetsScrollRenderController', () => {
beforeEach(() => {
pendingAnimationFrames = [];
@@ -92,7 +128,7 @@ describe('SheetsScrollRenderController', () => {
{ ctrlKey: false, shiftKey: false, deltaX: 7, deltaY: 10, preventDefault },
{ stopPropagation: () => { } }
);
- flushWheelFrame();
+ flushWheelFrame(scene);
expect(executeSpy).toHaveBeenCalledWith(SetScrollRelativeCommand.id, { offsetX: 7, offsetY: 10 });
@@ -107,7 +143,11 @@ describe('SheetsScrollRenderController', () => {
parentClassType: RENDER_CLASS_TYPE.ENGINE,
});
const { context, scene, contextService } = testBed;
- vi.spyOn(testBed.get(ICommandService), 'executeCommand').mockResolvedValue(true);
+ vi.spyOn(testBed.get(ICommandService), 'executeCommand').mockImplementation(async (_id, params) => {
+ const viewport = scene.getViewport(SHEET_VIEWPORT_KEY.VIEW_MAIN)!;
+ viewport.viewportScrollY += (params as { offsetY: number }).offsetY;
+ return true as never;
+ });
const preserveCacheSpy = vi.spyOn(scene, 'makeDirtyForScrolling');
const makeDirtySpy = vi.spyOn(scene, 'makeDirty');
const mainLayer = {
@@ -121,7 +161,7 @@ describe('SheetsScrollRenderController', () => {
{ ctrlKey: false, shiftKey: false, deltaX: 0, deltaY: 10, preventDefault: vi.fn() },
{ stopPropagation: vi.fn() }
);
- flushWheelFrame();
+ flushWheelFrame(scene);
expect(preserveCacheSpy).toHaveBeenCalledWith();
@@ -130,7 +170,7 @@ describe('SheetsScrollRenderController', () => {
{ ctrlKey: false, shiftKey: false, deltaX: 0, deltaY: 10, preventDefault: vi.fn() },
{ stopPropagation: vi.fn() }
);
- flushWheelFrame();
+ flushWheelFrame(scene);
expect(makeDirtySpy).toHaveBeenCalledWith(true);
expect(preserveCacheSpy).toHaveBeenCalledTimes(1);
@@ -140,11 +180,72 @@ describe('SheetsScrollRenderController', () => {
{ ctrlKey: false, shiftKey: false, deltaX: 0, deltaY: 10, preventDefault: vi.fn() },
{ stopPropagation: vi.fn() }
);
- flushWheelFrame();
+ flushWheelFrame(scene);
expect(makeDirtySpy).toHaveBeenCalledTimes(2);
void controller;
});
+ it.each([false, true])('preserves frozen viewport cache reuse armed by wheel scrolling with merges=%s', (hasMerges) => {
+ const testBed = createRenderTestBed({
+ dependencies: [[SheetScrollManagerService, { useValue: createScrollManagerServiceMock() }]],
+ parentClassType: RENDER_CLASS_TYPE.ENGINE,
+ });
+ const { context, contextService, scene, injector } = testBed;
+ const commands = injector.get(ICommandService);
+ let pending = false;
+ let armReuse = true;
+ scene.isViewportCacheReusePending = () => pending;
+ (context.mainComponent as any).getSkeleton = () => ({
+ worksheet: {
+ getMergeData: () => hasMerges ? [{ startRow: 0, endRow: 0, startColumn: 0, endColumn: 1 }] : [],
+ },
+ });
+ commands.registerCommand({
+ id: SetScrollRelativeCommand.id,
+ type: CommandType.COMMAND,
+ handler: () => {
+ pending = armReuse;
+ scene.getViewport(SHEET_VIEWPORT_KEY.VIEW_MAIN)!.viewportScrollY += 10;
+ return true;
+ },
+ });
+ injector.add([SheetsScrollRenderController, {
+ useFactory: () => injector.createInstance(SheetsScrollRenderController, context),
+ }]);
+ const controller = injector.get(SheetsScrollRenderController);
+ const dirty = vi.spyOn(scene, 'makeDirty');
+ const preserveEngine = vi.spyOn(scene, 'makeDirtyForScrolling');
+ contextService.setContextValue(FOCUSING_SHEET, true);
+ const wheel = () => {
+ scene.onMouseWheel$.emit(
+ { ctrlKey: false, shiftKey: false, deltaX: 0, deltaY: 10, preventDefault: vi.fn() },
+ { stopPropagation: vi.fn() }
+ );
+ flushWheelFrame(scene);
+ };
+
+ try {
+ wheel();
+ expect(scene.isViewportCacheReusePending()).toBe(true);
+ expect(dirty).not.toHaveBeenCalled();
+ expect(preserveEngine).not.toHaveBeenCalled();
+
+ pending = false;
+ armReuse = false;
+ wheel();
+ if (hasMerges) {
+ expect(dirty).toHaveBeenCalledExactlyOnceWith(true);
+ expect(preserveEngine).not.toHaveBeenCalled();
+ } else {
+ expect(preserveEngine).toHaveBeenCalledOnce();
+ expect(dirty).not.toHaveBeenCalled();
+ }
+ } finally {
+ controller.dispose();
+ testBed.univer.dispose();
+ }
+ });
+
it('uses shift-wheel horizontal scrolling and prevents default on scrollable viewport', () => {
const scrollManagerService = createScrollManagerServiceMock();
const testBed = createRenderTestBed({
@@ -168,7 +269,7 @@ describe('SheetsScrollRenderController', () => {
{ ctrlKey: false, shiftKey: true, deltaX: 3, deltaY: 7, preventDefault },
{ stopPropagation }
);
- flushWheelFrame();
+ flushWheelFrame(scene);
expect(executeSpy).toHaveBeenCalledWith(SetScrollRelativeCommand.id, { offsetX: 21, offsetY: 0 });
expect(preventDefault).toHaveBeenCalled();
@@ -211,7 +312,7 @@ describe('SheetsScrollRenderController', () => {
{ ctrlKey: false, shiftKey: false, deltaX: 0, deltaY: -40, preventDefault },
{ stopPropagation: () => { } }
);
- flushWheelFrame();
+ flushWheelFrame(scene);
expect(viewMain.limitedScroll).toHaveBeenCalledWith(0, 2);
expect(preventDefault).toHaveBeenCalled();
@@ -240,40 +341,91 @@ describe('SheetsScrollRenderController', () => {
{ ctrlKey: false, shiftKey: false, deltaX: 12, deltaY: 20, preventDefault },
{ stopPropagation: () => { } }
);
- flushWheelFrame();
+ flushWheelFrame(scene);
expect(executeSpy).toHaveBeenCalledWith(SetScrollRelativeCommand.id, { offsetX: 6, offsetY: 10 });
void controller;
});
- it('locks cross-axis jitter and coalesces wheel events into one engine frame', () => {
- const scrollManagerService = createScrollManagerServiceMock();
- const testBed = createRenderTestBed({
- dependencies: [[SheetScrollManagerService, { useValue: scrollManagerService }]],
- });
- const { context, scene, contextService } = testBed;
- const commandService = testBed.get(ICommandService);
- const executeSpy = vi.spyOn(commandService, 'executeCommand');
+ it('locks cross-axis jitter and coalesces wheel events into one engine frame', async () => {
+ const { execute, wheel, frame, viewport } = createRealScrollFixture();
+ wheel(8, 20);
+ wheel(20, 8);
+ expect(execute).not.toHaveBeenCalled();
+ await frame();
+ expect(execute.mock.calls.filter(([id]) => id === SetScrollRelativeCommand.id)).toEqual([
+ [SetScrollRelativeCommand.id, { offsetX: 20, offsetY: 20 }],
+ ]);
+ expect([viewport.viewportScrollX, viewport.viewportScrollY]).toEqual([20, 20]);
+ });
- contextService.setContextValue(FOCUSING_SHEET, true);
+ it('flushes accumulated wheel input before the next engine paint and cancels it on disposal', async () => {
+ const { execute, wheel, frame, controller, viewport } = createRealScrollFixture();
+ wheel(0, 10);
+ wheel(0, 20);
+ expect(execute).not.toHaveBeenCalled();
+ await frame();
+ expect(viewport.viewportScrollY).toBe(30);
+ expect(execute.mock.calls.filter(([id]) => id === SetScrollRelativeCommand.id)).toHaveLength(1);
+ wheel(0, 40);
+ controller.dispose();
+ await frame();
+ expect(viewport.viewportScrollY).toBe(30);
+ expect(execute.mock.calls.filter(([id]) => id === SetScrollRelativeCommand.id)).toHaveLength(1);
+ });
- const controller = testBed.injector.createInstance(SheetsScrollRenderController, context as any);
- const preventDefault = vi.fn();
+ it('does not invalidate the scene again when wheel input cannot move a clean viewport', async () => {
+ const { render, wheel, frame, viewport } = createRealScrollFixture();
+ await frame();
+ render.scene.makeDirty(false);
+ for (const view of render.scene.getViewports()) {
+ view.markDirty(false);
+ view.markForceDirty(false);
+ }
+ const dirty = vi.spyOn(render.scene, 'makeDirty');
+ const scrolling = vi.spyOn(render.scene, 'makeDirtyForScrolling');
+ wheel(0, -20);
+ await frame();
+ expect(viewport.viewportScrollY).toBe(0);
+ expect(dirty).not.toHaveBeenCalled();
+ expect(scrolling).not.toHaveBeenCalled();
+ });
+ it('retains the animation-frame fallback when the host has no engine frame signal', () => {
+ const testBed = createRenderTestBed({
+ dependencies: [[SheetScrollManagerService, { useValue: createScrollManagerServiceMock() }]],
+ });
+ const { scene, context, contextService, injector } = testBed;
+ vi.spyOn(scene, 'getEngine').mockReturnValue({ width: 800, height: 600 } as any);
+ const execute = vi.spyOn(injector.get(ICommandService), 'executeCommand').mockResolvedValue(true);
+ injector.add([SheetsScrollRenderController, { useFactory: () => injector.createInstance(SheetsScrollRenderController, context as any) }]);
+ const controller = injector.get(SheetsScrollRenderController);
+ contextService.setContextValue(FOCUSING_SHEET, true);
scene.onMouseWheel$.emit(
- { ctrlKey: false, shiftKey: false, deltaX: 8, deltaY: 20, preventDefault },
- { stopPropagation: () => { } }
- );
- scene.onMouseWheel$.emit(
- { ctrlKey: false, shiftKey: false, deltaX: 20, deltaY: 8, preventDefault },
- { stopPropagation: () => { } }
+ { ctrlKey: false, shiftKey: false, deltaX: 0, deltaY: 12, preventDefault: vi.fn() },
+ { stopPropagation: vi.fn() }
);
- flushWheelFrame();
-
- expect(executeSpy).toHaveBeenCalledTimes(1);
- expect(executeSpy).toHaveBeenCalledWith(SetScrollRelativeCommand.id, { offsetX: 20, offsetY: 20 });
+ expect(execute).not.toHaveBeenCalled();
+ expect(pendingAnimationFrames).toHaveLength(1);
+ flushWheelFrame(scene);
+ expect(execute).toHaveBeenCalledExactlyOnceWith(SetScrollRelativeCommand.id, { offsetX: 0, offsetY: 12 });
+ controller.dispose();
+ testBed.univer.dispose();
+ });
- void controller;
+ it.each(['deactivate', 'worksheet', 'focus'])('drops queued wheel input after changing %s', async (change) => {
+ const { render, injector, activate, execute, wheel, frame, viewport } = createRealScrollFixture();
+ wheel(0, 40);
+ if (change === 'deactivate') {
+ render.deactivate();
+ } else if (change === 'worksheet') {
+ activate('chart');
+ } else {
+ injector.get(IContextService).setContextValue(FOCUSING_SHEET, false);
+ }
+ await frame();
+ expect(execute.mock.calls.filter(([id]) => id === SetScrollRelativeCommand.id)).toHaveLength(0);
+ expect(viewport.viewportScrollY).toBe(0);
});
it('updates scroll state from viewport events and executes ScrollCommand when scrolling bar', () => {
diff --git a/packages/sheets-ui/src/controllers/render-controllers/__tests__/sheet-render-business.spec.ts b/packages/sheets-ui/src/controllers/render-controllers/__tests__/sheet-render-business.spec.ts
index 7332b9dff0..0662066bc9 100644
--- a/packages/sheets-ui/src/controllers/render-controllers/__tests__/sheet-render-business.spec.ts
+++ b/packages/sheets-ui/src/controllers/render-controllers/__tests__/sheet-render-business.spec.ts
@@ -97,14 +97,22 @@ vi.mock('@univerjs/engine-render', async (importOriginal) => {
});
function createCommandService() {
+ const beforeHandlers = new Set<(command: any, options?: any) => void>();
const handlers = new Set<(command: any, options?: any) => void>();
return {
+ beforeCommandExecuted: vi.fn((handler: (command: any, options?: any) => void) => {
+ beforeHandlers.add(handler);
+ return { dispose: vi.fn(() => beforeHandlers.delete(handler)) };
+ }),
onCommandExecuted: vi.fn((handler: (command: any, options?: any) => void) => {
handlers.add(handler);
return { dispose: vi.fn(() => handlers.delete(handler)) };
}),
- emit: (command: any, options?: any) => handlers.forEach((handler) => handler(command, options)),
+ emit: (command: any, options?: any) => {
+ beforeHandlers.forEach((handler) => handler(command, options));
+ handlers.forEach((handler) => handler(command, options));
+ },
};
}
@@ -119,6 +127,8 @@ function createController() {
enableLayerCache: vi.fn(),
attachControl: vi.fn(),
makeDirty: vi.fn(),
+ setViewportCacheReuseKey: vi.fn(),
+ invalidateViewportCacheReuse: vi.fn(),
getViewports: vi.fn(function (this: any) {
return this.__viewports;
}),
@@ -175,7 +185,7 @@ function createController() {
const injector = new Injector([
[IConfigService, { useValue: { getConfig: vi.fn(() => ({ scrollConfig: { barSize: 8 } })) } }],
[SheetSkeletonManagerService, { useValue: sheetSkeletonManagerService }],
- [SheetsRenderService, { useValue: { checkMutationShouldTriggerRerender: vi.fn((id: string) => id === 'sheet.custom-rerender') } }],
+ [SheetsRenderService, { useValue: { checkMutationShouldTriggerRerender: vi.fn((id: string) => id === 'sheet.custom-rerender'), shouldAutomaticallyRenderMutation: () => true } }],
[ICommandService, { useValue: commandService }],
[ITelemetryService, { useValue: telemetryService }],
]);
diff --git a/packages/sheets-ui/src/controllers/render-controllers/__tests__/sheet.render-controller.spec.ts b/packages/sheets-ui/src/controllers/render-controllers/__tests__/sheet.render-controller.spec.ts
index 3da88c3599..3c4c3f4938 100644
--- a/packages/sheets-ui/src/controllers/render-controllers/__tests__/sheet.render-controller.spec.ts
+++ b/packages/sheets-ui/src/controllers/render-controllers/__tests__/sheet.render-controller.spec.ts
@@ -14,18 +14,103 @@
* limitations under the License.
*/
-import { SheetTypes, ThemeService } from '@univerjs/core';
-import { SHEET_VIEWPORT_KEY, Viewport } from '@univerjs/engine-render';
-import { describe, expect, it } from 'vitest';
+import type { IWorkbookData, Workbook } from '@univerjs/core';
+import type { ISetArrayFormulaDataMutationParams } from '@univerjs/engine-formula';
+import type { IRenderContext } from '@univerjs/engine-render';
+import {
+ CommandType,
+ ICommandService,
+ IUniverInstanceService,
+ LocaleType,
+ SheetTypes,
+ ThemeService,
+ Univer,
+ UniverInstanceType,
+} from '@univerjs/core';
+import { SetArrayFormulaDataMutation } from '@univerjs/engine-formula';
+import { IRenderManagerService, SHEET_VIEWPORT_KEY, UniverRenderEnginePlugin, Viewport } from '@univerjs/engine-render';
+import { UniverSheetsPlugin } from '@univerjs/sheets';
+import { afterEach, describe, expect, it, vi } from 'vitest';
import { SHEET_VIEW_KEY } from '../../../common/keys';
import { SheetScrollManagerService } from '../../../services/scroll-manager.service';
+import { SheetSkeletonManagerService } from '../../../services/sheet-skeleton-manager.service';
+import { SheetsRenderService } from '../../../services/sheets-render.service';
import { HeaderFreezeRenderController } from '../freeze.render-controller';
-import { getLeftTopPlaceholderSize, SheetRenderController } from '../sheet.render-controller';
+import { getArrayFormulaSheetIds, getLeftTopPlaceholderSize, SheetRenderController } from '../sheet.render-controller';
import { SheetSkeletonRenderController } from '../skeleton.render-controller';
import { SheetsZoomRenderController } from '../zoom.render-controller';
import { createChartRenderTestBed } from './chart-render-test-bed';
+const EMPTY_ARRAY_RESULT: ISetArrayFormulaDataMutationParams = {
+ arrayFormulaCellData: {},
+ arrayFormulaRange: {},
+ arrayFormulaEmbedded: {},
+};
+
+function createCommandFixture() {
+ // Canvas drawing is unavailable in happy-dom; the renderer stays inactive throughout these command tests.
+ vi.spyOn(HTMLCanvasElement.prototype, 'getContext').mockImplementation(function (this: HTMLCanvasElement) {
+ return {
+ canvas: this,
+ setTransform: vi.fn(),
+ clearRect: vi.fn(),
+ measureText: () => ({ width: 0 }),
+ } as unknown as CanvasRenderingContext2D;
+ });
+ const univer = new Univer({ locale: LocaleType.EN_US });
+ univer.registerPlugin(UniverRenderEnginePlugin);
+ univer.registerPlugin(UniverSheetsPlugin);
+ const injector = univer.__getInjector();
+ const workbook = injector.get(IUniverInstanceService).createUnit<IWorkbookData, Workbook>(UniverInstanceType.UNIVER_SHEET, {
+ id: 'book',
+ name: 'Workbook',
+ sheetOrder: ['active', 'other'],
+ sheets: {
+ active: { id: 'active', name: 'Active', rowCount: 20, columnCount: 10 },
+ other: { id: 'other', name: 'Other', rowCount: 20, columnCount: 10 },
+ },
+ }, { skipAutoRender: true });
+ injector.add([SheetsRenderService]);
+ const render = injector.get(IRenderManagerService).createRender(workbook.getUnitId(), { makeCurrent: false });
+ const context = render.getRenderContext!() as IRenderContext<Workbook>;
+ const renderInjector = render.getInjector!();
+ renderInjector.add([SheetSkeletonManagerService, {
+ useFactory: () => renderInjector.createInstance(SheetSkeletonManagerService, context),
+ }]);
+ renderInjector.add([SheetRenderController, {
+ useFactory: () => renderInjector.createInstance(SheetRenderController, context),
+ }]);
+ renderInjector.get(SheetRenderController);
+ const commands = injector.get(ICommandService);
+ if (!commands.hasCommand(SetArrayFormulaDataMutation.id)) {
+ commands.registerCommand(SetArrayFormulaDataMutation);
+ }
+ const cells = vi.spyOn(render.mainComponent!, 'makeDirty');
+ const scene = vi.spyOn(render.scene, 'makeDirty');
+ const execute = (params: ISetArrayFormulaDataMutationParams) => {
+ cells.mockClear();
+ scene.mockClear();
+ expect(commands.syncExecuteCommand(SetArrayFormulaDataMutation.id, params)).toBe(true);
+ };
+ return { cells, commands, execute, scene, univer };
+}
+
+afterEach(() => vi.restoreAllMocks());
+
describe('SheetRenderController', () => {
+ it('tracks local spill data and ranges independently of foreign and empty sheets', () => {
+ const params = {
+ arrayFormulaCellData: { book: { active: { 2: { 3: { v: 42 } } }, empty: {} }, foreign: { other: { 0: { 0: { v: 1 } } } } },
+ arrayFormulaRange: { book: { rangeOnly: { 0: { 0: { startRow: 0, endRow: 2, startColumn: 0, endColumn: 0 } } } } },
+ };
+ const previous = getArrayFormulaSheetIds('book', params);
+ expect([...previous]).toEqual(['active', 'rangeOnly']);
+ const cleared = getArrayFormulaSheetIds('book', { arrayFormulaCellData: {}, arrayFormulaRange: {} });
+ expect(cleared.size).toBe(0);
+ expect(previous.has('active')).toBe(true);
+ expect(getArrayFormulaSheetIds('missing', params).size).toBe(0);
+ });
+
it('sizes the select-all placeholder from header margins', () => {
expect(getLeftTopPlaceholderSize({
rowHeaderWidth: 46,
@@ -38,6 +123,81 @@ describe('SheetRenderController', () => {
});
});
+ it('keeps the first notification conservative, then refreshes only the scene for unrelated array results', () => {
+ const fixture = createCommandFixture();
+ try {
+ fixture.execute(EMPTY_ARRAY_RESULT);
+ expect(fixture.cells).toHaveBeenCalledOnce();
+ expect(fixture.scene).toHaveBeenCalledOnce();
+
+ for (const params of [
+ EMPTY_ARRAY_RESULT,
+ { ...EMPTY_ARRAY_RESULT, arrayFormulaCellData: { foreign: { active: { 0: { 0: { v: 1 } } } } } },
+ { ...EMPTY_ARRAY_RESULT, arrayFormulaCellData: { book: { other: { 0: { 0: { v: 2 } } } } } },
+ ]) {
+ fixture.execute(params);
+ expect(fixture.cells).not.toHaveBeenCalled();
+ expect(fixture.scene).toHaveBeenCalledOnce();
+ }
+ } finally {
+ fixture.univer.dispose();
+ }
+ });
+
+ it('repaints active spill values and ranges and the notification that clears them', () => {
+ const fixture = createCommandFixture();
+ try {
+ fixture.execute(EMPTY_ARRAY_RESULT);
+ for (const params of [
+ { ...EMPTY_ARRAY_RESULT, arrayFormulaCellData: { book: { active: { 0: { 0: { v: 1 } } } } } },
+ { ...EMPTY_ARRAY_RESULT, arrayFormulaCellData: { book: { active: { 0: { 0: { v: 2 } } } } } },
+ {
+ ...EMPTY_ARRAY_RESULT,
+ arrayFormulaRange: { book: { active: { 0: { 0: { startRow: 0, endRow: 1, startColumn: 0, endColumn: 0 } } } } },
+ },
+ EMPTY_ARRAY_RESULT,
+ ]) {
+ fixture.execute(params);
+ expect(fixture.cells).toHaveBeenCalledOnce();
+ expect(fixture.scene).toHaveBeenCalledOnce();
+ }
+ fixture.execute(EMPTY_ARRAY_RESULT);
+ expect(fixture.cells).not.toHaveBeenCalled();
+ expect(fixture.scene).toHaveBeenCalledOnce();
+ } finally {
+ fixture.univer.dispose();
+ }
+ });
+
+ it('preserves full repaint for embedded array results, their removal, and unknown mutations', () => {
+ const fixture = createCommandFixture();
+ try {
+ fixture.execute(EMPTY_ARRAY_RESULT);
+ const embedded: ISetArrayFormulaDataMutationParams = {
+ ...EMPTY_ARRAY_RESULT,
+ arrayFormulaEmbedded: { foreign: { child: { 0: { 0: true } } } },
+ };
+ for (const params of [embedded, embedded, EMPTY_ARRAY_RESULT]) {
+ fixture.execute(params);
+ expect(fixture.cells).toHaveBeenCalledOnce();
+ expect(fixture.scene).toHaveBeenCalledOnce();
+ }
+ fixture.execute(EMPTY_ARRAY_RESULT);
+ expect(fixture.cells).not.toHaveBeenCalled();
+ expect(fixture.scene).toHaveBeenCalledOnce();
+
+ const unknownId = 'sheet.mutation.unknown-render-notification';
+ fixture.commands.registerCommand({ id: unknownId, type: CommandType.MUTATION, handler: () => true });
+ fixture.cells.mockClear();
+ fixture.scene.mockClear();
+ expect(fixture.commands.syncExecuteCommand(unknownId)).toBe(true);
+ expect(fixture.cells).toHaveBeenCalledOnce();
+ expect(fixture.scene).toHaveBeenCalledOnce();
+ } finally {
+ fixture.univer.dispose();
+ }
+ });
+
it('skips dirty bounds once the removed sheet has no skeleton param left', () => {
const { render, workbook, activate } = createChartRenderTestBed();
activate('grid');
diff --git a/packages/sheets-ui/src/controllers/render-controllers/freeze.render-controller.ts b/packages/sheets-ui/src/controllers/render-controllers/freeze.render-controller.ts
index 64631a0f70..ebcd86aab2 100644
--- a/packages/sheets-ui/src/controllers/render-controllers/freeze.render-controller.ts
+++ b/packages/sheets-ui/src/controllers/render-controllers/freeze.render-controller.ts
@@ -268,6 +268,8 @@ export class HeaderFreezeRenderController extends Disposable implements IRenderM
zIndex: 3,
});
+ this._rowFreezeHeaderRect.viewportCacheReusable = true;
+ this._rowFreezeMainRect.viewportCacheReusable = true;
scene.addObjects([this._rowFreezeHeaderRect, this._rowFreezeMainRect], SHEET_COMPONENT_HEADER_LAYER_INDEX);
} else {
if (freezeColumn === -1 || freezeColumn === 0) {
@@ -299,6 +301,8 @@ export class HeaderFreezeRenderController extends Disposable implements IRenderM
zIndex: 3,
});
+ this._columnFreezeHeaderRect.viewportCacheReusable = true;
+ this._columnFreezeMainRect.viewportCacheReusable = true;
scene.addObjects([this._columnFreezeHeaderRect, this._columnFreezeMainRect], SHEET_COMPONENT_HEADER_LAYER_INDEX);
}
diff --git a/packages/sheets-ui/src/controllers/render-controllers/mobile/__tests__/mobile-scroll.render-controller.spec.ts b/packages/sheets-ui/src/controllers/render-controllers/mobile/__tests__/mobile-scroll.render-controller.spec.ts
index 29c7ddfcbe..91194303b1 100644
--- a/packages/sheets-ui/src/controllers/render-controllers/mobile/__tests__/mobile-scroll.render-controller.spec.ts
+++ b/packages/sheets-ui/src/controllers/render-controllers/mobile/__tests__/mobile-scroll.render-controller.spec.ts
@@ -17,15 +17,25 @@
// @vitest-environment jsdom
import { ICommandService, RANGE_TYPE } from '@univerjs/core';
-import { SHEET_VIEWPORT_KEY } from '@univerjs/engine-render';
+import { DeviceType, ObjectType, Rect, SHEET_VIEWPORT_KEY, Vector2 } from '@univerjs/engine-render';
import { Subject } from 'rxjs';
-import { describe, expect, it, vi } from 'vitest';
+import { afterEach, describe, expect, it, vi } from 'vitest';
+import { createChartRenderTestBed } from '../../__tests__/chart-render-test-bed';
+import { createRenderTestBed } from '../../__tests__/render-test-bed';
import { ScrollCommand, SetScrollRelativeCommand } from '../../../../commands/commands/set-scroll.command';
import { SetZoomRatioCommand } from '../../../../commands/commands/set-zoom-ratio.command';
+import { SetScrollOperation } from '../../../../commands/operations/scroll.operation';
+import { SetZoomRatioOperation } from '../../../../commands/operations/set-zoom-ratio.operation';
import { SheetScrollManagerService } from '../../../../services/scroll-manager.service';
-import { createRenderTestBed } from '../../__tests__/render-test-bed';
+import { SheetsZoomRenderController } from '../../zoom.render-controller';
import { MobileSheetsScrollRenderController } from '../mobile-scroll.render-controller';
+const scrollControllers: MobileSheetsScrollRenderController[] = [];
+afterEach(() => {
+ scrollControllers.splice(0).forEach((controller) => controller.dispose());
+ vi.restoreAllMocks();
+});
+
function dispatchTouchEvent(
listeners: Map<string, EventListener>,
type: string,
@@ -52,6 +62,12 @@ function createController() {
const transformerChangeEnd$ = new Subject<unknown>();
let sceneObjectsEvented = true;
let sceneOverlayOwnsTouch = false;
+ const transformer = {
+ changeStart$: transformerChangeStart$,
+ changeEnd$: transformerChangeEnd$,
+ moveOnlyWhenSelected: false,
+ resetProps: vi.fn(),
+ };
const scrollStates = new Map<string, any>();
const scrollManagerService = {
rawScrollInfo$,
@@ -113,10 +129,7 @@ function createController() {
} as any);
Object.defineProperty(scene, 'getTransformerByCreate', {
configurable: true,
- value: () => ({
- changeStart$: transformerChangeStart$,
- changeEnd$: transformerChangeEnd$,
- }),
+ value: () => transformer,
});
Object.defineProperty(scene, 'objectsEvented', {
configurable: true,
@@ -127,7 +140,9 @@ function createController() {
value: () => sceneOverlayOwnsTouch ? scene : null,
});
- const controller = injector.createInstance(MobileSheetsScrollRenderController, context as any);
+ injector.add([MobileSheetsScrollRenderController, { useFactory: () => injector.createInstance(MobileSheetsScrollRenderController, context as any) }]);
+ const controller = injector.get(MobileSheetsScrollRenderController);
+ scrollControllers.push(controller);
return {
canvasElement,
@@ -156,7 +171,292 @@ function createController() {
};
}
+function createRealMobileFixture(zoomRatio = 1) {
+ const fixture = createChartRenderTestBed([
+ [SheetScrollManagerService],
+ [SheetsZoomRenderController],
+ [MobileSheetsScrollRenderController],
+ ], false, { rowCount: 1000, columnCount: 100, zoomRatio, freeze: { startRow: 0, startColumn: 0, xSplit: 0, ySplit: 0 } });
+ for (const command of [ScrollCommand, SetScrollRelativeCommand, SetScrollOperation, SetZoomRatioCommand, SetZoomRatioOperation]) {
+ fixture.commands.registerCommand(command);
+ }
+ const execute = vi.spyOn(fixture.commands, 'executeCommand');
+ let time = 1000;
+ const clock = vi.spyOn(performance, 'now').mockImplementation(() => time);
+ const canvas = fixture.render.engine.getCanvasElement();
+ const pointerCaptures = new Set<number>();
+ Object.defineProperties(canvas, {
+ setPointerCapture: { value: (id: number) => pointerCaptures.add(id) },
+ hasPointerCapture: { value: (id: number) => pointerCaptures.has(id) },
+ releasePointerCapture: { value: (id: number) => pointerCaptures.delete(id) },
+ });
+ const touch = (type: string, touches: Array<{ clientX: number; clientY: number }>) => {
+ const event = new Event(type, { cancelable: true });
+ Object.defineProperty(event, 'touches', { value: touches });
+ canvas.dispatchEvent(event);
+ return event;
+ };
+ const pointer = (type: string, id: number, x: number, y: number, pointerType = 'touch', isPrimary = false, target: EventTarget = canvas) => {
+ const event = new MouseEvent(type, { clientX: x, clientY: y, cancelable: true });
+ Object.defineProperties(event, {
+ pointerType: { value: pointerType },
+ pointerId: { value: id },
+ isPrimary: { value: isPrimary },
+ });
+ target.dispatchEvent(event);
+ return event;
+ };
+ const advance = (milliseconds = 16) => {
+ time += milliseconds;
+ };
+ const settle = () => Promise.all(execute.mock.results.filter((result) => result.type === 'return').map((result) => result.value));
+ const scrollCalls = () => execute.mock.calls.filter(([id]) => id === SetScrollRelativeCommand.id);
+ const swipe = async () => {
+ touch('touchstart', [{ clientX: 180, clientY: 300 }]);
+ for (let i = 1; i <= 6; i++) {
+ advance();
+ touch('touchmove', [{ clientX: 180, clientY: 300 - i * 20 }]);
+ await settle();
+ }
+ advance();
+ touch('touchend', []);
+ execute.mockClear();
+ };
+ const frame = (milliseconds = 16) => {
+ advance(milliseconds);
+ fixture.render.engine._beginFrame(time);
+ };
+ const addDrawing = (type: ObjectType) => {
+ const injector = fixture.render.getInjector!();
+ injector.add([Rect, {
+ useFactory: () => injector.createInstance(Rect, 'gesture-drawing', {
+ left: 0,
+ top: 0,
+ width: 1000,
+ height: 1000,
+ fill: '#ffffff',
+ }),
+ }]);
+ const drawing = injector.get(Rect);
+ drawing.setObjectType(type);
+ fixture.render.scene.addObject(drawing, 10);
+ return drawing;
+ };
+ const dispose = () => {
+ fixture.univer.dispose();
+ clock.mockRestore();
+ };
+ return {
+ ...fixture,
+ advance,
+ addDrawing,
+ canvas,
+ dispose,
+ execute,
+ touch,
+ pointer,
+ settle,
+ scrollCalls,
+ swipe,
+ frame,
+ controller: fixture.render.with(MobileSheetsScrollRenderController),
+ viewport: fixture.render.scene.getMainViewport(),
+ };
+}
+
describe('MobileSheetsScrollRenderController', () => {
+ it.each([0.5, 1, 2])('filters cross-axis touch drift before applying zoom %s and allows turns and diagonals', async (zoom) => {
+ const { advance, execute, scrollCalls, touch, settle, viewport } = createRealMobileFixture(zoom);
+ touch('touchstart', [{ clientX: 180, clientY: 180 }]);
+ advance();
+ touch('touchmove', [{ clientX: 179, clientY: 160 }]);
+ await settle();
+ expect(scrollCalls().at(-1)?.[1]).toEqual({ offsetX: 0, offsetY: 20 / zoom });
+ expect(viewport.viewportScrollX).toBe(0);
+ expect(viewport.viewportScrollY).toBeCloseTo(20 / zoom);
+
+ advance();
+ touch('touchmove', [{ clientX: 159, clientY: 161 }]);
+ await settle();
+ expect(scrollCalls().at(-1)?.[1]).toEqual({ offsetX: 20 / zoom, offsetY: 0 });
+ expect(viewport.viewportScrollX).toBeCloseTo(20 / zoom);
+ expect(viewport.viewportScrollY).toBeCloseTo(20 / zoom);
+
+ advance();
+ touch('touchmove', [{ clientX: 139, clientY: 141 }]);
+ await settle();
+ expect(scrollCalls().at(-1)?.[1]).toEqual({ offsetX: 20 / zoom, offsetY: 20 / zoom });
+ expect(viewport.viewportScrollX).toBeCloseTo(40 / zoom);
+ expect(viewport.viewportScrollY).toBeCloseTo(40 / zoom);
+
+ touch('touchcancel', []);
+ execute.mockClear();
+ advance();
+ touch('touchmove', [{ clientX: 119, clientY: 121 }]);
+ expect(execute).not.toHaveBeenCalled();
+ });
+
+ it.each([
+ { name: 'horizontal turn', moves: [[-1, -20], [-20, 1]], axis: 'x' },
+ { name: 'vertical turn', moves: [[-20, -1], [1, -20]], axis: 'y' },
+ { name: 'diagonal with horizontal intent', moves: [[-24, -20], [-24, -20]], axis: 'x' },
+ { name: 'diagonal with vertical intent', moves: [[-20, -24], [-20, -24]], axis: 'y' },
+ { name: 'balanced diagonal', moves: [[-20, -20], [-20, -20]], axis: 'y' },
+ { name: 'small horizontal release jitter', moves: [[0, -20], [0, -20], [-1, 0]], axis: 'y' },
+ { name: 'small vertical release jitter', moves: [[-20, 0], [-20, 0], [0, -1]], axis: 'x' },
+ ])('keeps inertia on one recent dominant axis after $name', async ({ moves, axis }) => {
+ const { advance, execute, frame, scrollCalls, settle, touch, viewport } = createRealMobileFixture();
+ const point = { clientX: 180, clientY: 180 };
+ touch('touchstart', [{ ...point }]);
+ for (const [x, y] of moves) {
+ advance();
+ point.clientX += x;
+ point.clientY += y;
+ touch('touchmove', [{ ...point }]);
+ await settle();
+ }
+ advance();
+ touch('touchend', []);
+ const released = { x: viewport.viewportScrollX, y: viewport.viewportScrollY };
+ execute.mockClear();
+ frame();
+ await settle();
+ const inertia = scrollCalls().at(-1)!;
+ const offsets = inertia[1] as { offsetX: number; offsetY: number };
+ expect(inertia[2]).toEqual({ fromMobileInertia: true });
+ expect(axis === 'x' ? offsets.offsetY : offsets.offsetX).toBe(0);
+ expect(axis === 'x' ? offsets.offsetX : offsets.offsetY).toBeGreaterThan(0);
+ expect(axis === 'x' ? viewport.viewportScrollY : viewport.viewportScrollX).toBe(axis === 'x' ? released.y : released.x);
+ expect(axis === 'x' ? viewport.viewportScrollX : viewport.viewportScrollY).toBeGreaterThan(axis === 'x' ? released.x : released.y);
+ touch('touchcancel', []);
+ });
+
+ it('navigates DOM drawings through forwarded touch pointers without changing mouse gestures', async () => {
+ const { addDrawing, advance, execute, pointer, render, settle, viewport, workbook } = createRealMobileFixture();
+ const drawing = addDrawing(ObjectType.CHART);
+ expect(render.scene.pick(Vector2.FromArray([120, 120]), DeviceType.Touch)).toBe(drawing);
+ pointer('pointerdown', 1, 120, 120, 'mouse');
+ advance();
+ pointer('pointermove', 1, 90, 80, 'mouse');
+ pointer('pointerup', 1, 90, 80, 'mouse');
+ expect(execute).not.toHaveBeenCalledWith(SetScrollRelativeCommand.id, expect.anything());
+ expect(viewport.viewportScrollY).toBe(0);
+
+ pointer('pointerdown', 1, 120, 120);
+ advance();
+ pointer('pointermove', 1, 90, 80);
+ await settle();
+ expect(execute).toHaveBeenCalledWith(SetScrollRelativeCommand.id, { offsetX: 30, offsetY: 40 });
+ expect(viewport.viewportScrollY).toBe(40);
+ advance();
+ pointer('pointermove', 1, 89, 60);
+ await settle();
+ expect(execute).toHaveBeenCalledWith(SetScrollRelativeCommand.id, { offsetX: 0, offsetY: 20 });
+ expect(viewport.viewportScrollY).toBe(60);
+ pointer('pointercancel', 1, 89, 60);
+ execute.mockClear();
+ pointer('pointermove', 1, 60, 40);
+ expect(execute).not.toHaveBeenCalled();
+
+ drawing.setObjectType(ObjectType.DRAWING_DOM);
+ pointer('pointerdown', 1, 120, 120);
+ advance();
+ pointer('pointermove', 1, 120, 100);
+ expect(execute).not.toHaveBeenCalledWith(SetScrollRelativeCommand.id, expect.anything());
+ expect(viewport.viewportScrollY).toBe(60);
+ pointer('pointerdown', 2, 220, 120);
+ pointer('pointermove', 2, 260, 120);
+ await settle();
+ expect(execute).toHaveBeenCalledWith(SetZoomRatioCommand.id, expect.objectContaining({ zoomRatio: 1.4 }));
+ expect(workbook.getActiveSheet().getZoomRatio()).toBe(1.4);
+ pointer('pointerup', 2, 260, 120);
+ pointer('pointerup', 1, 120, 120);
+ });
+
+ it.each(['captured-up', 'missing-up'])('does not interpret a new single chart touch as pinch after %s', async (release) => {
+ const addListener = vi.spyOn(HTMLCanvasElement.prototype, 'addEventListener');
+ const { addDrawing, advance, canvas, execute, pointer, render, settle, viewport } = createRealMobileFixture();
+ const drawing = addDrawing(ObjectType.CHART);
+ expect(render.scene.pick(Vector2.FromArray([120, 120]), DeviceType.Touch)).toBe(drawing);
+ pointer('pointerdown', 1, 120, 120, 'touch', true);
+ advance();
+ pointer('pointermove', 1, 120, 100);
+ await settle();
+ if (release === 'captured-up') {
+ // Native capture can deliver the up directly to the host canvas, without a DOM clone.
+ const canvasPointerUp = addListener.mock.calls.findLast(([type], index) => (
+ type === 'pointerup' && addListener.mock.contexts[index] === canvas
+ ))![1] as EventListener;
+ // DOM dispatch cannot create trusted events; supply the native capture boundary directly.
+ canvasPointerUp({
+ type: 'pointerup',
+ pointerType: 'touch',
+ pointerId: 1,
+ isTrusted: true,
+ preventDefault: vi.fn(),
+ } as unknown as Event);
+ execute.mockClear();
+ advance(8);
+ pointer('pointermove', 1, 120, 80);
+ expect(execute).not.toHaveBeenCalled();
+ }
+ execute.mockClear();
+ advance();
+ pointer('pointerdown', 2, 220, 220, 'touch', true);
+ advance();
+ const released = viewport.viewportScrollY;
+ pointer('pointermove', 2, 220, 200);
+ await settle();
+ expect(execute).not.toHaveBeenCalledWith(SetZoomRatioCommand.id, expect.anything());
+ expect(execute).toHaveBeenCalledWith(SetScrollRelativeCommand.id, { offsetX: 0, offsetY: 20 });
+ expect(viewport.viewportScrollY).toBe(released + 20);
+ pointer('pointercancel', 2, 220, 100);
+ });
+
+ it.each(['pointerup', 'pointercancel'])('cleans forwarded chart touches when %s occurs outside the canvas', async (type) => {
+ const removeListener = vi.spyOn(document, 'removeEventListener');
+ const { addDrawing, advance, controller, execute, pointer, render, settle, viewport } = createRealMobileFixture();
+ const drawing = addDrawing(ObjectType.CHART);
+ expect(render.scene.pick(Vector2.FromArray([120, 120]), DeviceType.Touch)).toBe(drawing);
+ pointer('pointerdown', 1, 120, 120);
+ advance();
+ pointer('pointermove', 1, 120, 100);
+ await settle();
+ pointer(type, 1, 120, 100, 'touch', false, document);
+ execute.mockClear();
+ advance();
+ pointer('pointermove', 1, 120, 80);
+ expect(execute).not.toHaveBeenCalled();
+ expect(viewport.viewportScrollY).toBe(20);
+ controller.dispose();
+ expect(removeListener).toHaveBeenCalledWith('pointerup', expect.any(Function), true);
+ expect(removeListener).toHaveBeenCalledWith('pointercancel', expect.any(Function), true);
+ });
+
+ it.each([ObjectType.IMAGE, ObjectType.SHAPE, ObjectType.CHART, ObjectType.DRAWING_DOM])('scrolls over unselected drawings of type %s but yields after they are selected', async (type) => {
+ const { addDrawing, advance, execute, render, settle, touch, viewport } = createRealMobileFixture();
+ const drawing = addDrawing(type);
+ const transformer = render.scene.getTransformerByCreate();
+ expect(render.scene.pick(Vector2.FromArray([120, 120]), DeviceType.Touch)).toBe(drawing);
+ expect(transformer.moveOnlyWhenSelected).toBe(true);
+ touch('touchstart', [{ clientX: 120, clientY: 120 }]);
+ advance();
+ touch('touchmove', [{ clientX: 90, clientY: 80 }]);
+ await settle();
+ expect(execute).toHaveBeenCalledWith(SetScrollRelativeCommand.id, { offsetX: 30, offsetY: 40 });
+ expect(viewport.viewportScrollY).toBe(40);
+
+ touch('touchend', []);
+ execute.mockClear();
+ transformer.setSelectedControl(drawing);
+ expect(transformer.getSelectedObjectMap().has(drawing.oKey)).toBe(true);
+ touch('touchstart', [{ clientX: 120, clientY: 120 }]);
+ advance();
+ touch('touchmove', [{ clientX: 90, clientY: 80 }]);
+ expect(execute).not.toHaveBeenCalledWith(SetScrollRelativeCommand.id, expect.anything());
+ expect(viewport.viewportScrollY).toBe(40);
+ });
+
it('scrolls the selected range into view based on the current viewport bounds', () => {
const { controller, syncExecuteCommand, testBed } = createController();
@@ -378,6 +678,102 @@ describe('MobileSheetsScrollRenderController', () => {
testBed.univer.dispose();
});
+ it.each([0.5, 1, 2])('keeps the same fling endpoint across refresh rates and dropped frames at zoom %s', async (zoom) => {
+ const distances: number[] = [];
+ for (const intervals of [[1000 / 60], [1000 / 30], [1000 / 120], [8, 40, 15, 100, 5]]) {
+ const { controller, dispose, execute, frame, scrollCalls, settle, swipe, viewport } = createRealMobileFixture(zoom);
+ await swipe();
+ const releaseY = viewport.viewportScrollY;
+ for (let i = 0; i < 150; i++) {
+ frame(intervals[i % intervals.length]);
+ await settle();
+ }
+ distances.push(viewport.viewportScrollY - releaseY);
+ expect(distances.at(-1)).toBeGreaterThan(0);
+ const completedCalls = scrollCalls().length;
+ expect(completedCalls).toBeGreaterThan(0);
+ execute.mockClear();
+ frame();
+ await settle();
+ expect(execute).not.toHaveBeenCalled();
+ controller.dispose();
+ dispose();
+ }
+ for (const distance of distances) {
+ expect(distance).toBeCloseTo(distances[0], 9);
+ }
+ });
+
+ it.each([false, true])('stops at a blocked viewport after pending geometry work=%s', async (pendingGeometry) => {
+ const { advance, commands, execute, frame, scrollCalls, settle, touch, viewport } = createRealMobileFixture();
+ await commands.executeCommand(ScrollCommand.id, { sheetViewStartRow: 999, offsetY: 0 });
+ const edge = viewport.viewportScrollY;
+ expect(edge).toBeGreaterThan(0);
+ touch('touchstart', [{ clientX: 180, clientY: 180 }]);
+ advance();
+ touch('touchmove', [{ clientX: 180, clientY: 140 }]);
+ await settle();
+ advance();
+ touch('touchend', []);
+ execute.mockClear();
+ viewport.markDirty(pendingGeometry);
+ viewport.markForceDirty(false);
+ for (let i = 0; i < 10; i++) {
+ frame();
+ await settle();
+ viewport.markDirty(false);
+ }
+ expect(scrollCalls()).toHaveLength(pendingGeometry ? 2 : 1);
+ expect(viewport.viewportScrollY).toBe(edge);
+ execute.mockClear();
+ frame();
+ await settle();
+ expect(execute).not.toHaveBeenCalled();
+ });
+
+ it('commits inertia before paint and waits for an asynchronous command without overlapping updates', async () => {
+ const { swipe, frame, settle, execute, viewport, controller } = createRealMobileFixture();
+ await swipe();
+ const released = viewport.viewportScrollY;
+ expect(released).toBeGreaterThan(0);
+ frame();
+ frame();
+ expect(execute.mock.calls.filter(([id]) => id === SetScrollRelativeCommand.id)).toHaveLength(1);
+ await settle();
+ expect(viewport.viewportScrollY).toBeGreaterThan(released);
+ const beforeDispose = viewport.viewportScrollY;
+ controller.dispose();
+ frame();
+ await settle();
+ expect(viewport.viewportScrollY).toBe(beforeDispose);
+ expect(execute.mock.calls.filter(([id]) => id === SetScrollRelativeCommand.id)).toHaveLength(1);
+ });
+
+ it.each(['touchcancel', 'touchstart', 'pinch', 'drawing', 'deactivate'])('cancels a pending inertia frame on %s', async (action) => {
+ const { swipe, frame, settle, execute, render, touch, viewport, controller } = createRealMobileFixture();
+ await swipe();
+ const released = viewport.viewportScrollY;
+ if (action === 'drawing') {
+ const injector = render.getInjector!();
+ injector.add([Rect, { useFactory: () => injector.createInstance(Rect, 'inertia-drawing', { left: 10, top: 10, width: 40, height: 40 }) }]);
+ const drawing = injector.get(Rect);
+ render.scene.addObject(drawing);
+ render.scene.getTransformerByCreate().activeAnObject(drawing);
+ } else if (action === 'deactivate') {
+ render.deactivate();
+ } else if (action === 'pinch') {
+ touch('touchstart', [{ clientX: 120, clientY: 140 }, { clientX: 180, clientY: 140 }]);
+ } else {
+ touch(action, action === 'touchstart' ? [{ clientX: 180, clientY: 140 }] : []);
+ }
+ execute.mockClear();
+ frame();
+ await settle();
+ expect(execute).not.toHaveBeenCalled();
+ expect(viewport.viewportScrollY).toBe(released);
+ controller.dispose();
+ });
+
it('yields an active touch gesture to shape adjustment controls', () => {
const { canvasListeners, executeCommand, setSceneObjectsEvented, testBed } = createController();
const preventDefault = 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 614882f29a..6bead52940 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
@@ -17,8 +17,7 @@
import type { IFreeze, IRange, Nullable, Workbook } from '@univerjs/core';
import type { IMouseEvent, IPoint, IPointerEvent, IRenderContext, IRenderModule, IScrollObserverParam } from '@univerjs/engine-render';
import type { IScrollToCellOperationParams, ISheetSkeletonManagerParam } from '@univerjs/sheets';
-import type { IExpandSelectionCommandParams } from '../../../commands/commands/set-selection.command';
-import type { IScrollState, IScrollStateSearchParam, IViewportScrollState } from '../../../services/scroll-manager.service';
+import type { Subscription } from 'rxjs';
import {
Direction,
Disposable,
@@ -29,9 +28,12 @@ import {
RANGE_TYPE,
toDisposable,
} from '@univerjs/core';
-import { DeviceType, IRenderManagerService, SHEET_VIEWPORT_KEY, Vector2 } from '@univerjs/engine-render';
+import { DeviceType, DrawingGroupObject, IRenderManagerService, ObjectType, Scene, SHEET_VIEWPORT_KEY, Vector2 } from '@univerjs/engine-render';
import { ScrollToCellOperation, SheetsSelectionsService } from '@univerjs/sheets';
import { MobileZoomIndicator } from '@univerjs/ui';
+import { take } from 'rxjs';
+import type { IExpandSelectionCommandParams } from '../../../commands/commands/set-selection.command';
+import type { IScrollState, IScrollStateSearchParam, IViewportScrollState } from '../../../services/scroll-manager.service';
import { ScrollCommand, SetScrollRelativeCommand } from '../../../commands/commands/set-scroll.command';
import { ExpandSelectionCommand, MoveSelectionCommand, MoveSelectionEnterAndTabCommand } from '../../../commands/commands/set-selection.command';
import { SetZoomRatioCommand } from '../../../commands/commands/set-zoom-ratio.command';
@@ -40,7 +42,14 @@ import { SheetScrollManagerService } from '../../../services/scroll-manager.serv
import { SheetSkeletonManagerService } from '../../../services/sheet-skeleton-manager.service';
import { getSheetObject } from '../../utils/component-tools';
+const TOUCH_CROSS_AXIS_LOCK_RATIO = 2;
const SHEET_NAVIGATION_COMMANDS = [MoveSelectionCommand.id, MoveSelectionEnterAndTabCommand.id];
+const SHEET_DRAWING_OBJECT_TYPES = [ObjectType.IMAGE, ObjectType.SHAPE, ObjectType.CHART, ObjectType.DRAWING_DOM];
+
+interface IMobileTouchEvent {
+ touches: ArrayLike<Pick<Touch, 'clientX' | 'clientY'>>;
+ preventDefault(): void;
+}
/**
* This controller handles scroll logic in sheet interaction.
@@ -318,7 +327,11 @@ export class MobileSheetsScrollRenderController extends Disposable implements IR
const scene = sheetObject.scene;
const spreadsheet = sheetObject.spreadsheet;
const transformer = scene.getTransformerByCreate();
+ const moveOnlyWhenSelected = transformer.moveOnlyWhenSelected;
+ transformer.resetProps({ moveOnlyWhenSelected: true });
+ this.disposeWithMe(toDisposable(() => transformer.resetProps({ moveOnlyWhenSelected })));
const viewportMain = scene.getViewport(SHEET_VIEWPORT_KEY.VIEW_MAIN);
+ const engine = scene.getEngine();
const lastTouchPos: IPoint = { x: 0, y: 0 };
let _touchScrolling: boolean = false;
let _drawingTransforming: boolean = false;
@@ -326,6 +339,16 @@ export class MobileSheetsScrollRenderController extends Disposable implements IR
// Velocity tracking for smooth inertia (iOS-like)
const velocity = { x: 0, y: 0 };
let scrollInertiaAnimationID: null | number = null;
+ let inertiaFrameSubscription: Subscription | null = null;
+ let inertiaMotion: {
+ startTime: number;
+ duration: number;
+ sheetId: string;
+ velocityX: number;
+ velocityY: number;
+ distanceX: number;
+ distanceY: number;
+ } | null = null;
// Track velocity history for smoother calculation (like iOS)
const VELOCITY_HISTORY_SIZE = 5;
@@ -336,14 +359,12 @@ export class MobileSheetsScrollRenderController extends Disposable implements IR
let swipeStartTime = 0;
let swipeTotalDisplacement = { x: 0, y: 0 };
- // Direction locking - prevent simultaneous X/Y scrolling
- let lockedDirection: 'x' | 'y' | null = null;
- const DIRECTION_LOCK_THRESHOLD = 8; // px - minimum movement to lock direction
-
// iOS-like physics constants (tuned for smoother feel)
const BASE_DECELERATION_RATE = 0.992; // Per millisecond deceleration (lower = stops faster)
const BASE_MIN_VELOCITY_THRESHOLD = 0.22; // Minimum velocity to continue animation
const BASE_MAX_VELOCITY = 12; // Cap maximum velocity for stability
+ // Keep the established 60Hz fling distance while integrating independently of frame intervals.
+ const INERTIA_DISTANCE_SCALE = BASE_DECELERATION_RATE ** (1000 / 60);
// Flick detection thresholds
const FLICK_TIME_THRESHOLD = 240; // ms - swipes faster than this are considered "flicks"
@@ -441,21 +462,28 @@ export class MobileSheetsScrollRenderController extends Disposable implements IR
/**
* iOS-like inertia animation with time-based deceleration
*/
- let lastFrameTime = 0;
let _pinchZooming = false;
let initialPinchDistance = 0;
let initialZoomRatio = 1;
let pinchCenter: IPoint = { x: 0, y: 0 };
const cancelInertiaAnimation = () => {
+ inertiaFrameSubscription?.unsubscribe();
+ inertiaFrameSubscription = null;
+ inertiaMotion = null;
if (scrollInertiaAnimationID !== null) {
cancelAnimationFrame(scrollInertiaAnimationID);
scrollInertiaAnimationID = null;
}
- lastFrameTime = 0;
velocity.x = 0;
velocity.y = 0;
};
+ this.disposeWithMe(toDisposable(this._context.activated$.subscribe((active) => {
+ if (!active) {
+ cancelInertiaAnimation();
+ }
+ })));
+
this.disposeWithMe(toDisposable(transformer.changeStart$.subscribe(() => {
_drawingTransforming = true;
_touchScrolling = false;
@@ -466,52 +494,67 @@ export class MobileSheetsScrollRenderController extends Disposable implements IR
_drawingTransforming = false;
})));
- const scrollInertia = (currentTime: number) => {
- if (!viewportMain) return;
-
- // Stop inertia if pinch zooming has started
- if (_pinchZooming) {
- cancelInertiaAnimation();
+ const scrollInertia = async (currentTime: number) => {
+ const motion = inertiaMotion;
+ if (!motion || !viewportMain) {
return;
}
- if (lastFrameTime === 0) {
- lastFrameTime = currentTime;
- scrollInertiaAnimationID = requestAnimationFrame(scrollInertia);
+ if (_pinchZooming || this._context.unit.getActiveSheet()?.getSheetId() !== motion.sheetId) {
+ cancelInertiaAnimation();
return;
}
-
- const deltaTime = currentTime - lastFrameTime;
- lastFrameTime = currentTime;
-
- const { decelerationRate, minVelocityThreshold } = getZoomAdjustedParams();
-
- // Apply time-based exponential deceleration (iOS-like)
- const decelerationFactor = decelerationRate ** deltaTime;
- velocity.x *= decelerationFactor;
- velocity.y *= decelerationFactor;
-
- // Calculate displacement for this frame
- // Using integral of velocity over time for smoother motion
+ const elapsed = Math.min(motion.duration, Math.max(0, currentTime - motion.startTime));
+ const { decelerationRate } = getZoomAdjustedParams();
const dampingFactor = -Math.log(decelerationRate);
- const offsetX = velocity.x * (1 - decelerationFactor) / dampingFactor;
- const offsetY = velocity.y * (1 - decelerationFactor) / dampingFactor;
-
- if (Math.abs(offsetX) > 0.01 || Math.abs(offsetY) > 0.01) {
- this._commandService.executeCommand(SetScrollRelativeCommand.id, { offsetY, offsetX });
+ const distanceFactor = (1 - decelerationRate ** elapsed) / dampingFactor * INERTIA_DISTANCE_SCALE;
+ const distanceX = motion.velocityX * distanceFactor;
+ const distanceY = motion.velocityY * distanceFactor;
+ const offsetX = distanceX - motion.distanceX;
+ const offsetY = distanceY - motion.distanceY;
+ const previousX = viewportMain.viewportScrollX;
+ const previousY = viewportMain.viewportScrollY;
+
+ if (offsetX !== 0 || offsetY !== 0) {
+ try {
+ await this._commandService.executeCommand(SetScrollRelativeCommand.id, { offsetY, offsetX }, { fromMobileInertia: true });
+ } catch (error) {
+ if (inertiaMotion === motion) {
+ cancelInertiaAnimation();
+ }
+ throw error;
+ }
+ if (inertiaMotion !== motion) {
+ return;
+ }
+ if (viewportMain.viewportScrollX === previousX && viewportMain.viewportScrollY === previousY &&
+ !viewportMain.isDirty && !viewportMain.isForceDirty) {
+ cancelInertiaAnimation();
+ return;
+ }
}
-
- // Continue animation if velocity is above threshold
- const speed = Math.sqrt(velocity.x * velocity.x + velocity.y * velocity.y);
- if (speed > minVelocityThreshold) {
- scrollInertiaAnimationID = requestAnimationFrame(scrollInertia);
+ motion.distanceX = distanceX;
+ motion.distanceY = distanceY;
+ if (elapsed < motion.duration) {
+ queueInertiaFrame();
} else {
- scrollInertiaAnimationID = null;
- lastFrameTime = 0;
+ cancelInertiaAnimation();
}
};
+ function queueInertiaFrame() {
+ if (engine?.beginFrame$) {
+ inertiaFrameSubscription = engine.beginFrame$.pipe(take(1)).subscribe(() => {
+ inertiaFrameSubscription = null;
+ return scrollInertia(performance.now());
+ });
+ } else {
+ scrollInertiaAnimationID = requestAnimationFrame((time) => {
+ scrollInertiaAnimationID = null;
+ return scrollInertia(time);
+ });
+ }
+ }
// Get the canvas element for native touch events
- const engine = scene.getEngine();
const canvasElement = engine?.getCanvasElement();
if (!canvasElement) return;
@@ -539,7 +582,7 @@ export class MobileSheetsScrollRenderController extends Disposable implements IR
/**
* Convert touch event to offset coordinates relative to canvas
*/
- const getTouchOffset = (touch: Touch): { offsetX: number; offsetY: number } => {
+ const getTouchOffset = (touch: Pick<Touch, 'clientX' | 'clientY'>): { offsetX: number; offsetY: number } => {
const rect = canvasElement.getBoundingClientRect();
return {
offsetX: touch.clientX - rect.left,
@@ -550,7 +593,7 @@ export class MobileSheetsScrollRenderController extends Disposable implements IR
/**
* Calculate distance between two touch points
*/
- const getTouchDistance = (touch1: Touch, touch2: Touch): number => {
+ const getTouchDistance = (touch1: Pick<Touch, 'clientX' | 'clientY'>, touch2: Pick<Touch, 'clientX' | 'clientY'>): number => {
const dx = touch1.clientX - touch2.clientX;
const dy = touch1.clientY - touch2.clientY;
return Math.sqrt(dx * dx + dy * dy);
@@ -559,7 +602,7 @@ export class MobileSheetsScrollRenderController extends Disposable implements IR
/**
* Get center point between two touches (in canvas coordinates)
*/
- const getPinchCenter = (touch1: Touch, touch2: Touch): IPoint => {
+ const getPinchCenter = (touch1: Pick<Touch, 'clientX' | 'clientY'>, touch2: Pick<Touch, 'clientX' | 'clientY'>): IPoint => {
const offset1 = getTouchOffset(touch1);
const offset2 = getTouchOffset(touch2);
return {
@@ -699,7 +742,7 @@ export class MobileSheetsScrollRenderController extends Disposable implements IR
});
// Helper function to initialize pinch zoom state
- const initializePinchZoom = (touch1: Touch, touch2: Touch) => {
+ const initializePinchZoom = (touch1: Pick<Touch, 'clientX' | 'clientY'>, touch2: Pick<Touch, 'clientX' | 'clientY'>) => {
_pinchZooming = true;
this._contextService.setContextValue(MOBILE_PINCH_ZOOMING, true);
initialPinchDistance = getTouchDistance(touch1, touch2);
@@ -729,7 +772,7 @@ export class MobileSheetsScrollRenderController extends Disposable implements IR
};
// Native touch event handlers for better mobile scrolling experience
- const handleTouchStart = (e: TouchEvent) => {
+ const handleTouchStart = (e: IMobileTouchEvent) => {
// Handle pinch-to-zoom (two fingers)
cancelInertiaAnimation();
if (_drawingTransforming || scene.objectsEvented === false) {
@@ -776,18 +819,24 @@ export class MobileSheetsScrollRenderController extends Disposable implements IR
// Only start scrolling if touch is on spreadsheet area
if (!isTouchOnSpreadsheet(offsetX, offsetY)) return;
- // A drawing, selection handle, or another canvas overlay owns this gesture.
- // Native touch listeners bypass the render event propagation chain, so the
- // sheet scroller must explicitly yield to the picked overlay object.
+ // Unselected drawings allow sheet navigation; selected drawings and controls own the gesture.
const pickedObject = scene.pick(Vector2.FromArray([offsetX, offsetY]), DeviceType.Touch);
- if (pickedObject && pickedObject !== spreadsheet) return;
+ if (pickedObject && pickedObject !== spreadsheet) {
+ if (pickedObject instanceof Scene) {
+ return;
+ }
+ const drawing = pickedObject.ancestorGroup ?? pickedObject;
+ const isDrawing = drawing instanceof DrawingGroupObject || SHEET_DRAWING_OBJECT_TYPES.includes(pickedObject.objectType);
+ if (!isDrawing || transformer.getSelectedObjectMap().has(drawing.oKey)) {
+ return;
+ }
+ }
lastTouchPos.x = offsetX;
lastTouchPos.y = offsetY;
lastMoveTime = performance.now();
swipeStartTime = lastMoveTime;
swipeTotalDisplacement = { x: 0, y: 0 };
- lockedDirection = null; // Reset direction lock on new touch
velocityHistory.length = 0;
_touchScrolling = true;
@@ -796,7 +845,7 @@ export class MobileSheetsScrollRenderController extends Disposable implements IR
};
// eslint-disable-next-line max-lines-per-function
- const handleTouchMove = (e: TouchEvent) => {
+ const handleTouchMove = (e: IMobileTouchEvent) => {
if (_drawingTransforming || scene.objectsEvented === false) {
_touchScrolling = false;
velocityHistory.length = 0;
@@ -864,25 +913,20 @@ export class MobileSheetsScrollRenderController extends Disposable implements IR
// When zoomed in, divide by larger ratio = less scroll (less sensitive)
// When zoomed out, divide by smaller ratio = more scroll (more responsive)
const zoomRatio = getCurrentZoomRatio();
- const deltaX = rawDeltaX / zoomRatio;
- const deltaY = rawDeltaY / zoomRatio;
+ let deltaX = rawDeltaX / zoomRatio;
+ let deltaY = rawDeltaY / zoomRatio;
+ // Match wheel filtering without locking the gesture: deliberate diagonals and turns remain available.
+ if (Math.abs(rawDeltaY) >= Math.abs(rawDeltaX) * TOUCH_CROSS_AXIS_LOCK_RATIO) {
+ deltaX = 0;
+ } else if (Math.abs(rawDeltaX) >= Math.abs(rawDeltaY) * TOUCH_CROSS_AXIS_LOCK_RATIO) {
+ deltaY = 0;
+ }
- // Track total displacement for flick detection and direction locking (used for inertia only)
+ // Track total displacement for flick detection.
// Use raw values for gesture detection to maintain consistent flick recognition
swipeTotalDisplacement.x += Math.abs(rawDeltaX);
swipeTotalDisplacement.y += Math.abs(rawDeltaY);
- // Direction locking logic - lock to primary axis once threshold is reached
- // Note: This only affects inertia scrolling, not the actual touchmove scroll
- if (lockedDirection === null) {
- const totalX = swipeTotalDisplacement.x;
- const totalY = swipeTotalDisplacement.y;
- if (totalX > DIRECTION_LOCK_THRESHOLD || totalY > DIRECTION_LOCK_THRESHOLD) {
- // Lock to the axis with more displacement (for inertia only)
- lockedDirection = totalX > totalY ? 'x' : 'y';
- }
- }
-
// Calculate instantaneous velocity (pixels per millisecond)
// Track both directions for velocity history
const instantVelX = deltaX / deltaTime * 16;
@@ -913,7 +957,7 @@ export class MobileSheetsScrollRenderController extends Disposable implements IR
e.preventDefault();
};
- const handleTouchEnd = (e: TouchEvent) => {
+ const handleTouchEnd = (e: IMobileTouchEvent) => {
if (e.touches.length === 0) {
_drawingTransforming = false;
}
@@ -962,16 +1006,24 @@ export class MobileSheetsScrollRenderController extends Disposable implements IR
const cappedVelX = Math.max(-maxVelocity, Math.min(maxVelocity, avgVelocity.x * dynamicMultiplier));
const cappedVelY = Math.max(-maxVelocity, Math.min(maxVelocity, avgVelocity.y * dynamicMultiplier));
- // Apply direction lock for inertia - only scroll in the primary direction
- // This makes inertia feel more controlled while touchmove allows free movement
- velocity.x = lockedDirection === 'y' ? 0 : cappedVelX;
- velocity.y = lockedDirection === 'x' ? 0 : cappedVelY;
+ // Use recent weighted motion so release jitter cannot turn a fling onto the other axis.
+ const horizontal = Math.abs(avgVelocity.x) > Math.abs(avgVelocity.y);
+ velocity.x = horizontal ? cappedVelX : 0;
+ velocity.y = horizontal ? 0 : cappedVelY;
// Only start inertia if velocity is significant
const speed = Math.sqrt(velocity.x * velocity.x + velocity.y * velocity.y);
if (speed > minVelocityThreshold * 2) {
- lastFrameTime = 0;
- scrollInertiaAnimationID = requestAnimationFrame(scrollInertia);
+ inertiaMotion = {
+ startTime: performance.now(),
+ duration: Math.log(speed / minVelocityThreshold) / -Math.log(BASE_DECELERATION_RATE),
+ sheetId: this._context.unit.getActiveSheet().getSheetId(),
+ velocityX: velocity.x,
+ velocityY: velocity.y,
+ distanceX: 0,
+ distanceY: 0,
+ };
+ queueInertiaFrame();
}
velocityHistory.length = 0;
@@ -996,6 +1048,61 @@ export class MobileSheetsScrollRenderController extends Disposable implements IR
};
// Add native touch event listeners with passive: false to allow preventDefault
+ // DOM drawings forward pointer events to the canvas, but their native touches stay on the DOM.
+ const forwardedTouches = new Map<number, PointerEvent>();
+ let domOwnsForwardedPan = false;
+ const finishForwardedPointer = (event: PointerEvent) => {
+ if (event.pointerType !== 'touch' || !forwardedTouches.delete(event.pointerId)) {
+ return;
+ }
+ if (event.type === 'pointercancel') {
+ handleTouchCancel();
+ } else {
+ handleTouchEnd({ touches: Array.from(forwardedTouches.values()), preventDefault: () => event.preventDefault() });
+ }
+ };
+ const handleForwardedPointer = (event: PointerEvent) => {
+ if (event.pointerType !== 'touch') {
+ return;
+ }
+ if (event.type === 'pointerdown' && event.isPrimary && forwardedTouches.size) {
+ // A new primary touch cannot coexist with pointers left over from an interrupted gesture.
+ forwardedTouches.clear();
+ handleTouchCancel();
+ }
+ if (event.type === 'pointerup' || event.type === 'pointercancel') {
+ finishForwardedPointer(event);
+ return;
+ }
+ if (event.isTrusted) {
+ return;
+ }
+ if (event.type === 'pointerdown') {
+ forwardedTouches.set(event.pointerId, event);
+ if (forwardedTouches.size === 1) {
+ const { offsetX, offsetY } = getTouchOffset(event);
+ const picked = scene.pick(Vector2.FromArray([offsetX, offsetY]), DeviceType.Touch);
+ // DOM blocks route their native touch pan to the host; chart DOM only forwards pointers.
+ domOwnsForwardedPan = !(picked instanceof Scene) && picked?.objectType === ObjectType.DRAWING_DOM;
+ }
+ if (!domOwnsForwardedPan || forwardedTouches.size > 1) {
+ handleTouchStart({ touches: Array.from(forwardedTouches.values()), preventDefault: () => event.preventDefault() });
+ }
+ } else if (forwardedTouches.has(event.pointerId)) {
+ if (event.type === 'pointermove') {
+ forwardedTouches.set(event.pointerId, event);
+ if (!domOwnsForwardedPan || forwardedTouches.size > 1) {
+ handleTouchMove({ touches: Array.from(forwardedTouches.values()), preventDefault: () => event.preventDefault() });
+ }
+ }
+ }
+ };
+ // Pointer capture can end a DOM gesture on the canvas or outside its original layer.
+ document.addEventListener('pointerup', finishForwardedPointer, true);
+ document.addEventListener('pointercancel', finishForwardedPointer, true);
+ const forwardedPointerEvents = ['pointerdown', 'pointermove', 'pointerup', 'pointercancel'] as const;
+ forwardedPointerEvents.forEach((type) => canvasElement.addEventListener(type, handleForwardedPointer));
+
canvasElement.addEventListener('touchstart', handleTouchStart, { passive: false });
canvasElement.addEventListener('touchmove', handleTouchMove, { passive: false });
canvasElement.addEventListener('touchend', handleTouchEnd, { passive: false });
@@ -1007,6 +1114,11 @@ export class MobileSheetsScrollRenderController extends Disposable implements IR
canvasElement.removeEventListener('touchmove', handleTouchMove);
canvasElement.removeEventListener('touchend', handleTouchEnd);
canvasElement.removeEventListener('touchcancel', handleTouchCancel);
+ forwardedPointerEvents.forEach((type) => canvasElement.removeEventListener(type, handleForwardedPointer));
+ document.removeEventListener('pointerup', finishForwardedPointer, true);
+ document.removeEventListener('pointercancel', finishForwardedPointer, true);
+ handleTouchCancel();
+ forwardedTouches.clear();
zoomIndicator.dispose();
}));
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 4a78b781a7..438529d99e 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
@@ -27,6 +27,7 @@ import type {
ISetSelectionsOperationParams,
SheetsSelectionsService,
} from '@univerjs/sheets';
+import type { Subscription } from 'rxjs';
import {
Direction,
Disposable,
@@ -42,6 +43,7 @@ import {
} from '@univerjs/core';
import { IRenderManagerService, RENDER_CLASS_TYPE, SHEET_VIEWPORT_KEY } from '@univerjs/engine-render';
import { getSelectionsService, ScrollToCellOperation, SetSelectionsOperation } from '@univerjs/sheets';
+import { take } from 'rxjs';
import type { IScrollCommandParams } from '../../commands/commands/set-scroll.command';
import type { IExpandSelectionCommandParams } from '../../commands/commands/set-selection.command';
import type {
@@ -66,6 +68,8 @@ export class SheetsScrollRenderController extends Disposable implements IRenderM
private _pendingWheelFrameId: number | null = null;
private _scrollGeneration = 0;
private readonly _selectionScrollTimers = new Set<ReturnType<typeof setTimeout>>();
+ private _pendingWheelFrameSubscription: Subscription | null = null;
+ private _pendingWheelSheetId: string | undefined;
constructor(
private readonly _context: IRenderContext<Workbook>,
@@ -98,11 +102,21 @@ export class SheetsScrollRenderController extends Disposable implements IRenderM
this.disposeWithMe(toDisposable(() => {
this._cancelPendingScroll();
}));
+ this.disposeWithMe(toDisposable(this._context.activated$.subscribe((active) => {
+ if (!active) {
+ this._cancelPendingWheelScroll();
+ }
+ })));
this.disposeWithMe(
scene.onMouseWheel$.subscribeEvent((evt: IWheelEvent, state) => {
if (evt.ctrlKey || !this._contextService.getContextValue(FOCUSING_SHEET)) {
return;
}
+ const sheetId = this._context.unit.getActiveSheet(true)?.getSheetId();
+ if (this._pendingWheelSheetId !== sheetId) {
+ this._cancelPendingWheelScroll();
+ }
+ this._pendingWheelSheetId = sheetId;
let offsetX = 0;
let offsetY = 0;
@@ -133,17 +147,7 @@ export class SheetsScrollRenderController extends Disposable implements IRenderM
// add offset on scroll position to check whether scrolling is reaching limit
this._pendingWheelOffsetX += offsetX;
this._pendingWheelOffsetY += offsetY;
- if (this._pendingWheelFrameId == null) {
- const generation = this._scrollGeneration;
- const worksheet = this._context.unit.getActiveSheet();
- this._pendingWheelFrameId = requestAnimationFrame(() => {
- if (this._disposed || generation !== this._scrollGeneration || worksheet !== this._context.unit.getActiveSheet()) {
- return;
- }
- this._pendingWheelFrameId = null;
- this._flushPendingWheelScroll();
- });
- }
+ this._queueWheelScroll();
const targetViewportScrollX = viewMain.viewportScrollX + this._pendingWheelOffsetX;
const targetViewportScrollY = viewMain.viewportScrollY + this._pendingWheelOffsetY;
const { x: targetScrollX, y: targetScrollY } = viewMain.transViewportScroll2ScrollValue(
@@ -169,6 +173,35 @@ export class SheetsScrollRenderController extends Disposable implements IRenderM
);
}
+ private _queueWheelScroll() {
+ if (this._pendingWheelFrameId != null || this._pendingWheelFrameSubscription != null) {
+ return;
+ }
+ const engine = this._context.scene.getEngine();
+ const flush = () => {
+ this._pendingWheelFrameId = null;
+ this._pendingWheelFrameSubscription = null;
+ this._flushPendingWheelScroll();
+ };
+ if (engine?.beginFrame$) {
+ this._pendingWheelFrameSubscription = engine.beginFrame$.pipe(take(1)).subscribe(flush);
+ } else {
+ this._pendingWheelFrameId = requestAnimationFrame(flush);
+ }
+ }
+
+ private _cancelPendingWheelScroll() {
+ this._pendingWheelFrameSubscription?.unsubscribe();
+ this._pendingWheelFrameSubscription = null;
+ if (this._pendingWheelFrameId != null) {
+ cancelAnimationFrame(this._pendingWheelFrameId);
+ this._pendingWheelFrameId = null;
+ }
+ this._pendingWheelOffsetX = 0;
+ this._pendingWheelOffsetY = 0;
+ this._pendingWheelSheetId = undefined;
+ }
+
private _flushPendingWheelScroll() {
const offsetX = this._pendingWheelOffsetX;
const offsetY = this._pendingWheelOffsetY;
@@ -178,14 +211,25 @@ export class SheetsScrollRenderController extends Disposable implements IRenderM
this._pendingWheelOffsetX = 0;
this._pendingWheelOffsetY = 0;
+ const sheetId = this._pendingWheelSheetId;
+ this._pendingWheelSheetId = undefined;
+ if (sheetId !== this._context.unit.getActiveSheet(true)?.getSheetId() ||
+ !this._contextService.getContextValue(FOCUSING_SHEET)) {
+ return;
+ }
if (this._getSheetType() === SheetTypes.CHART) {
this._context.scene.getMainViewport().scrollByViewportDeltaVal({ viewportScrollX: offsetX, viewportScrollY: offsetY });
this._context.scene.makeDirty();
return;
}
+ const viewMain = this._context.scene.getViewport(SHEET_VIEWPORT_KEY.VIEW_MAIN);
+ const previousX = viewMain?.viewportScrollX;
+ const previousY = viewMain?.viewportScrollY;
const canUseScrollFastPath = this._canUseScrollFastPath();
this._commandService.executeCommand(SetScrollRelativeCommand.id, { offsetX, offsetY });
- this._markSceneDirtyForScrolling(canUseScrollFastPath);
+ if (!viewMain || viewMain.viewportScrollX !== previousX || viewMain.viewportScrollY !== previousY) {
+ this._markSceneDirtyForScrolling(canUseScrollFastPath);
+ }
}
private _canUseScrollFastPath() {
@@ -205,6 +249,9 @@ export class SheetsScrollRenderController extends Disposable implements IRenderM
private _markSceneDirtyForScrolling(canUseScrollFastPath: boolean) {
const { scene } = this._context;
+ if (scene.isViewportCacheReusePending()) {
+ return;
+ }
if (canUseScrollFastPath) {
scene.makeDirtyForScrolling();
} else {
@@ -347,12 +394,7 @@ export class SheetsScrollRenderController extends Disposable implements IRenderM
private _cancelPendingScroll() {
this._scrollGeneration++;
- if (this._pendingWheelFrameId != null) {
- cancelAnimationFrame(this._pendingWheelFrameId);
- this._pendingWheelFrameId = null;
- }
- this._pendingWheelOffsetX = 0;
- this._pendingWheelOffsetY = 0;
+ this._cancelPendingWheelScroll();
this._selectionScrollTimers.forEach((timer) => clearTimeout(timer));
this._selectionScrollTimers.clear();
const viewport = this._context.scene.getMainViewport();
diff --git a/packages/sheets-ui/src/controllers/render-controllers/sheet.render-controller.ts b/packages/sheets-ui/src/controllers/render-controllers/sheet.render-controller.ts
index 8927648d77..d8971d780c 100644
--- a/packages/sheets-ui/src/controllers/render-controllers/sheet.render-controller.ts
+++ b/packages/sheets-ui/src/controllers/render-controllers/sheet.render-controller.ts
@@ -14,40 +14,11 @@
* limitations under the License.
*/
-import type {
- BooleanNumber,
- ICommandInfo,
- IExecutionOptions,
- IRange,
- Nullable,
- Workbook,
- Worksheet,
-} from '@univerjs/core';
-import type { ISetFormulaCalculationNotificationMutation } from '@univerjs/engine-formula';
-import type {
- IAfterRender$Info,
- IBasicFrameInfo,
- IExtendFrameInfo,
- IRenderContext,
- IRenderModule,
- IScrollBarProps,
- ISummaryFrameInfo,
- ISummaryMetric,
- ITimeMetric,
- IViewportInfos,
- Scene,
-} from '@univerjs/engine-render';
-import {
- CommandType,
- ICommandService,
- IConfigService,
- Inject,
- Optional,
- Rectangle,
- RxDisposable,
- SheetTypes,
-} from '@univerjs/core';
-import { SetFormulaCalculationNotificationMutation } from '@univerjs/engine-formula';
+import type { BooleanNumber, ICommandInfo, IExecutionOptions, IRange, Nullable, Workbook, Worksheet } from '@univerjs/core';
+import type { ISetArrayFormulaDataMutationParams, ISetFormulaCalculationNotificationMutation } from '@univerjs/engine-formula';
+import type { IAfterRender$Info, IBasicFrameInfo, IExtendFrameInfo, IRenderContext, IRenderModule, IScrollBarProps, ISummaryFrameInfo, ISummaryMetric, ITimeMetric, IViewportInfos, Scene } from '@univerjs/engine-render';
+import { CommandType, ICommandService, IConfigService, Inject, Optional, Rectangle, RxDisposable, SheetTypes, toDisposable } from '@univerjs/core';
+import { FormulaDataModel, SetArrayFormulaDataMutation, SetFormulaCalculationNotificationMutation } from '@univerjs/engine-formula';
import {
Rect,
ScrollBar,
@@ -67,6 +38,8 @@ import {
import { ITelemetryService } from '@univerjs/telemetry';
import { Subject, withLatestFrom } from 'rxjs';
import type { IUniverSheetsUIConfig } from '../../config/config';
+import { SetScrollRelativeCommand } from '../../commands/commands/set-scroll.command';
+import { SetScrollOperation } from '../../commands/operations/scroll.operation';
import {
SHEET_COMPONENT_HEADER_LAYER_INDEX,
SHEET_COMPONENT_MAIN_LAYER_INDEX,
@@ -92,6 +65,8 @@ export interface ITelemetryData {
const FRAME_STACK_THRESHOLD = 60;
export class SheetRenderController extends RxDisposable implements IRenderModule {
+ private _arrayFormulaSheets: Set<string> | undefined;
+ private _hadEmbeddedArrayData: boolean | undefined;
private _renderMetric$: Subject<ITelemetryData> = new Subject();
renderMetric$ = this._renderMetric$.asObservable();
constructor(
@@ -100,9 +75,16 @@ export class SheetRenderController extends RxDisposable implements IRenderModule
@Inject(SheetSkeletonManagerService) private readonly _sheetSkeletonManagerService: SheetSkeletonManagerService,
@Inject(SheetsRenderService) private readonly _sheetRenderService: SheetsRenderService,
@ICommandService private readonly _commandService: ICommandService,
- @Optional(ITelemetryService) private readonly _telemetryService?: ITelemetryService
+ @Optional(ITelemetryService) private readonly _telemetryService?: ITelemetryService,
+ @Optional(FormulaDataModel) private readonly _formulaDataModel?: FormulaDataModel
) {
super();
+ if (this._formulaDataModel) {
+ this._arrayFormulaSheets = getArrayFormulaSheetIds(this._context.unitId, {
+ arrayFormulaCellData: this._formulaDataModel.getArrayFormulaCellData(),
+ arrayFormulaRange: this._formulaDataModel.getArrayFormulaRange(),
+ });
+ }
this._addNewRender();
this._initRenderMetricSubscriber();
}
@@ -282,6 +264,9 @@ export class SheetRenderController extends RxDisposable implements IRenderModule
strokeWidth: 1,
});
+ SpreadsheetLeftTopPlaceholder.viewportCacheReusable = true;
+ scene.setViewportCacheReuseKey(SHEET_VIEWPORT_KEY.VIEW_MAIN);
+ this.disposeWithMe(toDisposable(() => scene.setViewportCacheReuseKey(null)));
this._context.mainComponent = spreadsheet;
components.set(SHEET_VIEW_KEY.MAIN, spreadsheet);
components.set(SHEET_VIEW_KEY.ROW, spreadsheetRowHeader);
@@ -496,6 +481,11 @@ export class SheetRenderController extends RxDisposable implements IRenderModule
}
private _initCommandListener(): void {
+ this.disposeWithMe(this._commandService.beforeCommandExecuted((command) => {
+ if (command.id !== SetScrollRelativeCommand.id && command.id !== SetScrollOperation.id) {
+ this._context.scene.invalidateViewportCacheReuse();
+ }
+ }));
this.disposeWithMe(this._commandService.onCommandExecuted((command: ICommandInfo, options) => {
const { unit: workbook } = this._context;
const { id: commandId } = command;
@@ -542,10 +532,28 @@ export class SheetRenderController extends RxDisposable implements IRenderModule
}
private _markUnitDirty(command: ICommandInfo, options: IExecutionOptions | undefined) {
- if (command.id.substring(0, 3) === 'doc') {
+ if (command.id.substring(0, 3) === 'doc' || !this._sheetRenderService.shouldAutomaticallyRenderMutation(command.id)) {
return;
}
+ let repaintCells = true;
+ if (command.id === SetArrayFormulaDataMutation.id && command.params) {
+ const params = command.params as ISetArrayFormulaDataMutationParams;
+ const affected = getArrayFormulaSheetIds(this._context.unitId, params);
+ const previous = this._arrayFormulaSheets;
+ this._arrayFormulaSheets = affected;
+ const sheetId = this._context.unit.getActiveSheet()?.getSheetId();
+ const hadEmbedded = this._hadEmbeddedArrayData;
+ const hasEmbedded = Object.values(params.arrayFormulaEmbedded ?? {})
+ .some((unit) => Object.values(unit ?? {}).some((matrix) => Object.keys(matrix ?? {}).length > 0));
+ this._hadEmbeddedArrayData = hasEmbedded;
+ // Linked drawings still need a scene refresh even when the active sheet has no changed spill cells.
+ if (previous && sheetId && !previous.has(sheetId) && !affected.has(sheetId)
+ && hadEmbedded === false && !hasEmbedded) {
+ repaintCells = false;
+ }
+ }
+
const { mainComponent: spreadsheet, scene } = this._context;
if (command.id === SetFormulaCalculationNotificationMutation.id) {
@@ -555,7 +563,7 @@ export class SheetRenderController extends RxDisposable implements IRenderModule
}
}
- if (spreadsheet) {
+ if (spreadsheet && repaintCells) {
spreadsheet.makeDirty(); // refresh spreadsheet
}
@@ -667,6 +675,22 @@ export class SheetRenderController extends RxDisposable implements IRenderModule
}
}
+export function getArrayFormulaSheetIds(
+ unitId: string,
+ params: Pick<ISetArrayFormulaDataMutationParams, 'arrayFormulaCellData' | 'arrayFormulaRange'>
+): Set<string> {
+ const sheets = new Set<string>();
+ for (const units of [params.arrayFormulaCellData, params.arrayFormulaRange]) {
+ const data = units?.[unitId];
+ for (const sheetId in data) {
+ if (data[sheetId] && Object.keys(data[sheetId]).length) {
+ sheets.add(sheetId);
+ }
+ }
+ }
+ return sheets;
+}
+
export function getLeftTopPlaceholderSize(skeleton: {
rowHeaderWidth: number;
columnHeaderHeight: number;
diff --git a/packages/sheets-ui/src/services/__tests__/sheets-render.service.spec.ts b/packages/sheets-ui/src/services/__tests__/sheets-render.service.spec.ts
index 365cb5504f..6b1aef3def 100644
--- a/packages/sheets-ui/src/services/__tests__/sheets-render.service.spec.ts
+++ b/packages/sheets-ui/src/services/__tests__/sheets-render.service.spec.ts
@@ -137,6 +137,20 @@ function createLifecycleService() {
}
describe('SheetsRenderService', () => {
+ it('keeps unknown mutations conservative and releases self-rendering registrations by owner', () => {
+ const service = createService();
+ const first = service.registerSelfRenderingMutations('derived.view');
+ const second = service.registerSelfRenderingMutations('derived.view');
+ expect(service.shouldAutomaticallyRenderMutation('unknown')).toBe(true);
+ expect(service.shouldAutomaticallyRenderMutation('derived.view')).toBe(false);
+ first.dispose();
+ first.dispose();
+ expect(service.shouldAutomaticallyRenderMutation('derived.view')).toBe(false);
+ second.dispose();
+ expect(service.shouldAutomaticallyRenderMutation('derived.view')).toBe(true);
+ service.dispose();
+ });
+
it('tracks mutations that require rebuilding the sheet skeleton and unregisters them by disposable', () => {
const service = createService();
const disposable = service.registerSkeletonChangingMutations('sheet.mutation.resize-row');
diff --git a/packages/sheets-ui/src/services/sheets-render.service.ts b/packages/sheets-ui/src/services/sheets-render.service.ts
index b1d9ae8b5d..2c85afc57e 100644
--- a/packages/sheets-ui/src/services/sheets-render.service.ts
+++ b/packages/sheets-ui/src/services/sheets-render.service.ts
@@ -34,6 +34,7 @@ const SHEET_MAIN_CANVAS_ID = 'univer-sheet-main-canvas';
*/
export class SheetsRenderService extends RxDisposable {
private _skeletonChangeMutations = new Set<string>();
+ private readonly _selfRenderingMutations = new Map<string, number>();
constructor(
@IContextService private readonly _contextService: IContextService,
@@ -69,6 +70,23 @@ export class SheetsRenderService extends RxDisposable {
return this._skeletonChangeMutations.has(id);
}
+ /** The owning plugin must invalidate the affected sheets when its derived view changes. */
+ registerSelfRenderingMutations(mutationId: string): IDisposable {
+ this._selfRenderingMutations.set(mutationId, (this._selfRenderingMutations.get(mutationId) ?? 0) + 1);
+ return toDisposable(() => {
+ const remaining = (this._selfRenderingMutations.get(mutationId) ?? 1) - 1;
+ if (remaining) {
+ this._selfRenderingMutations.set(mutationId, remaining);
+ } else {
+ this._selfRenderingMutations.delete(mutationId);
+ }
+ });
+ }
+
+ shouldAutomaticallyRenderMutation(mutationId: string): boolean {
+ return !this._selfRenderingMutations.has(mutationId);
+ }
+
private _init() {
this._initWorkbookListener();
this._initContextListener();
diff --git a/packages/sheets-ui/src/views/formula-bar/__tests__/FormulaBar.spec.tsx b/packages/sheets-ui/src/views/formula-bar/__tests__/FormulaBar.spec.tsx
index e8c63f68ee..2f26f0f414 100644
--- a/packages/sheets-ui/src/views/formula-bar/__tests__/FormulaBar.spec.tsx
+++ b/packages/sheets-ui/src/views/formula-bar/__tests__/FormulaBar.spec.tsx
@@ -76,7 +76,6 @@ import enUS from '../../../locale/en-US';
import { EditorBridgeService, IEditorBridgeService } from '../../../services/editor-bridge.service';
import { FormulaEditorManagerService, IFormulaEditorManagerService } from '../../../services/editor/formula-editor-manager.service';
import { MobileFormulaBar } from '../../mobile/formula-bar/MobileFormulaBar';
-import { MobileFormulaBarOverlays } from '../../mobile/formula-bar/MobileFormulaBarControls';
import { FormulaBar } from '../FormulaBar';
(globalThis as { IS_REACT_ACT_ENVIRONMENT?: boolean }).IS_REACT_ACT_ENVIRONMENT = true;
@@ -617,64 +616,6 @@ describe('FormulaBar', () => {
subscription.unsubscribe();
});
- it('prevents mobile formula bar actions from stealing editor focus', async () => {
- currentBed = createFormulaBarTestBed();
- const forceFormulaMode: boolean[] = [];
- const subscription = currentBed.injector.get(IFormulaEditorManagerService).fxBtnClick$.subscribe((value) => {
- forceFormulaMode.push(value);
- });
- const rendered = renderWithDependencies(<MobileFormulaBar />, currentBed.injector);
- root = rendered.root;
- container = rendered.container;
- const formulaButton = getActionElement(rendered.container, 2);
- const pointerDownEvents = [0, 1, 2].map(() => new MouseEvent('pointerdown', {
- bubbles: true,
- cancelable: true,
- }));
-
- await act(async () => {
- pointerDownEvents.forEach((event, index) => {
- getActionElement(rendered.container, index).dispatchEvent(event);
- });
- await Promise.resolve();
- });
- await clickElement(formulaButton);
-
- expect(pointerDownEvents.every((event) => event.defaultPrevented)).toBe(true);
- expect(forceFormulaMode).toEqual([true]);
- expect(currentBed.editorBridgeService.isVisible().visible).toBe(true);
- subscription.unsubscribe();
- });
-
- it('keeps editor focus while inserting a mobile formula operator', async () => {
- currentBed = createFormulaBarTestBed();
- const onOperator = vi.fn();
- const rendered = renderWithDependencies(
- <MobileFormulaBarOverlays
- expanded={false}
- formulaActive
- operatorsVisible
- editorId={DOCS_FORMULA_BAR_EDITOR_UNIT_ID_KEY}
- onOperator={onOperator}
- />,
- currentBed.injector
- );
- root = rendered.root;
- container = rendered.container;
- const commaButton = rendered.container.querySelector<HTMLButtonElement>('button[aria-label=","]');
- const pointerDownEvent = new MouseEvent('pointerdown', { bubbles: true, cancelable: true });
-
- if (!commaButton) throw new Error('Expected the comma operator button to be rendered.');
- await act(async () => {
- commaButton.dispatchEvent(pointerDownEvent);
- commaButton.click();
- await Promise.resolve();
- });
-
- expect(pointerDownEvent.defaultPrevented).toBe(true);
- expect(onOperator).toHaveBeenCalledWith(',');
- });
-
it('commits, moves down, and exits editing from the compact mobile formula bar', async () => {
currentBed = createFormulaBarTestBed();
const rendered = renderWithDependencies(<MobileFormulaBar />, currentBed.injector);
diff --git a/packages/sheets-ui/src/views/mobile/action-panel/MobileSheetActionPanel.tsx b/packages/sheets-ui/src/views/mobile/action-panel/MobileSheetActionPanel.tsx
index cbee335073..cd99530a9c 100644
--- a/packages/sheets-ui/src/views/mobile/action-panel/MobileSheetActionPanel.tsx
+++ b/packages/sheets-ui/src/views/mobile/action-panel/MobileSheetActionPanel.tsx
@@ -26,11 +26,13 @@ import {
IContextService,
Injector,
IPermissionService,
+ IUniverInstanceService,
LocaleService,
+ UniverInstanceType,
} from '@univerjs/core';
-import { clsx, resetButtonClassName, useMobileKeyboardViewportLayout } from '@univerjs/design';
+import { Button, clsx, resetButtonClassName, useMobileKeyboardViewportLayout } from '@univerjs/design';
import { IEditorService } from '@univerjs/docs-ui';
-import { DeviceInputEventType } from '@univerjs/engine-render';
+import { DeviceInputEventType, IRenderManagerService } from '@univerjs/engine-render';
import { KeyboardIcon, MenuIcon, MoreLeftIcon } from '@univerjs/icons';
import {
checkRangesEditablePermission,
@@ -54,7 +56,7 @@ import {
useObservable,
} from '@univerjs/ui';
import { useCallback, useEffect, useMemo, useRef, useState } from 'react';
-import { map, merge, startWith } from 'rxjs';
+import { map, merge, of, startWith } from 'rxjs';
import type { IUniverSheetsUIConfig } from '../../../config/config';
import type { LocaleKey } from '../../../locale/types';
import type { IMobileStyleCommand, MobileStyleView } from './MobileStylePanel';
@@ -67,6 +69,7 @@ import {
MOBILE_KEYBOARD_VISIBLE,
} from '../../../consts/mobile-context';
import { IEditorBridgeService } from '../../../services/editor-bridge.service';
+import { ISheetEmbedRuntimeFocusCoordinator } from '../../../services/sheet-embed-integration.service';
import { useActiveWorkbook } from '../../hook';
import { MobileStylePanel } from './MobileStylePanel';
@@ -150,6 +153,22 @@ export function getMobileMenuCommand(params: IValueOption | IMobileStyleCommand)
}
export function MobileSheetActionPanel() {
+ const instances = useDependency(IUniverInstanceService);
+ const injector = useDependency(Injector);
+ const localeService = useDependency(LocaleService);
+ const focusCoordinator = injector.has(ISheetEmbedRuntimeFocusCoordinator)
+ ? injector.get(ISheetEmbedRuntimeFocusCoordinator)
+ : undefined;
+ const resolveChildOwnsTools = () => {
+ const scope = focusCoordinator?.resolveActiveChildSessionRuntimeScope();
+ return scope != null && scope.hostUnitId === instances.getCurrentUnitOfType(UniverInstanceType.UNIVER_SHEET)?.getUnitId() && scope.childType !== UniverInstanceType.UNIVER_SHEET;
+ };
+ const childOwnsTools = useObservable(
+ () => focusCoordinator?.runtimeSessionChanged$.pipe(startWith(undefined), map(resolveChildOwnsTools)) ?? of(false),
+ resolveChildOwnsTools(),
+ false,
+ [focusCoordinator, instances]
+ );
const contextService = useDependency(IContextService);
const focusingDrawing = useObservable(
() => contextService.subscribeContextValue$(FOCUSING_COMMON_DRAWINGS).pipe(map(Boolean)),
@@ -158,10 +177,39 @@ export function MobileSheetActionPanel() {
[contextService]
);
- if (focusingDrawing) {
+ function exitDrawingSelection() {
+ const workbook = instances.getCurrentUnitOfType(UniverInstanceType.UNIVER_SHEET);
+ const transformer = workbook
+ ? injector.get(IRenderManagerService).getRenderUnitById(workbook.getUnitId())?.scene.getTransformer()
+ : undefined;
+ transformer?.finishTransform();
+ transformer?.clearSelectedObjects();
+ contextService.setContextValue(FOCUSING_COMMON_DRAWINGS, false);
+ }
+
+ if (childOwnsTools) {
return null;
}
+ if (focusingDrawing) {
+ return (
+ <Button
+ type="button"
+ variant="primary"
+ size="large"
+ className="
+ univer-pointer-events-auto univer-absolute univer-bottom-14 univer-right-4 univer-z-50 univer-h-12
+ univer-rounded-full univer-px-4 univer-shadow-lg
+ "
+ style={{ marginBottom: 'env(safe-area-inset-bottom, 0px)' }}
+ onClick={exitDrawingSelection}
+ >
+ <MoreLeftIcon />
+ {localeService.t<LocaleKey>('sheets-ui.mobile.back')}
+ </Button>
+ );
+ }
+
return <MobileSheetActionPanelContent />;
}
diff --git a/packages/sheets-ui/src/views/mobile/action-panel/__tests__/MobileSheetActionPanel.spec.ts b/packages/sheets-ui/src/views/mobile/action-panel/__tests__/MobileSheetActionPanel.spec.ts
index b1e8d3a502..2a736c4971 100644
--- a/packages/sheets-ui/src/views/mobile/action-panel/__tests__/MobileSheetActionPanel.spec.ts
+++ b/packages/sheets-ui/src/views/mobile/action-panel/__tests__/MobileSheetActionPanel.spec.ts
@@ -31,6 +31,7 @@ import {
UniverInstanceType,
} from '@univerjs/core';
import { IEditorService } from '@univerjs/docs-ui';
+import { IRenderManagerService, RenderManagerService } from '@univerjs/engine-render';
import {
getPrimaryForRange,
RangeProtectionRuleModel,
@@ -62,7 +63,6 @@ import { IEditorBridgeService } from '../../../../services/editor-bridge.service
import {
getMobileCellCenterOffset,
getMobileCellRevealOffset,
- getMobileEditingMenuBottomOffset,
getMobileMenuCommand,
MobileSheetActionPanel,
normalizeMobileSelectionPrimary,
@@ -115,7 +115,7 @@ function createNumberFormatRibbon(): IMenuSchema[] {
}];
}
-function renderMobileSheetActionPanel(ribbon: IMenuSchema[] = []) {
+async function renderMobileSheetActionPanel(ribbon: IMenuSchema[] = []) {
const univer = new Univer();
const injector = univer.__getInjector();
const contextService = injector.get(IContextService);
@@ -137,6 +137,7 @@ function renderMobileSheetActionPanel(ribbon: IMenuSchema[] = []) {
}]);
injector.add([IEditorService, { useValue: { focus: vi.fn() } as unknown as IEditorService }]);
injector.add([ILayoutService, { useValue: { focus: vi.fn() } as unknown as ILayoutService }]);
+ injector.add([IRenderManagerService, { useClass: RenderManagerService }]);
injector.add([ComponentManager]);
injector.add([IconManager]);
injector.add([IMenuManagerService, {
@@ -168,7 +169,7 @@ function renderMobileSheetActionPanel(ribbon: IMenuSchema[] = []) {
const container = document.createElement('div');
document.body.appendChild(container);
const root = createRoot(container);
- act(() => {
+ await act(async () => {
root.render(createElement(
RediContext.Provider,
{ value: { injector } },
@@ -205,8 +206,8 @@ function disposeRenderedPanel(root: Root, container: HTMLElement, univer: Univer
}
describe('mobile sheet action panel visibility', () => {
- it('disables both keyboard entrances when cell editing is forbidden', () => {
- const { commandService, container, permissions, root, subUnitId, univer } = renderMobileSheetActionPanel();
+ it('disables both keyboard entrances when cell editing is forbidden', async () => {
+ const { commandService, container, permissions, root, subUnitId, univer } = await renderMobileSheetActionPanel();
const startEditing = vi.fn(() => true);
commandService.registerCommand({ ...SetCellEditVisibleOperation, handler: startEditing });
const keyboard = () => container.querySelector<HTMLButtonElement>(
@@ -229,8 +230,22 @@ describe('mobile sheet action panel visibility', () => {
}
});
- it('does not reopen the previous sheet drawer after drawing focus ends', () => {
- const { container, contextService, root, univer } = renderMobileSheetActionPanel();
+ it('keeps an exit available while a drawing owns touch gestures', async () => {
+ const { container, contextService, root, univer } = await renderMobileSheetActionPanel();
+
+ try {
+ act(() => contextService.setContextValue(FOCUSING_COMMON_DRAWINGS, true));
+ expect(container.querySelector('[aria-label="Open sheet tools"]')).toBeNull();
+ clickButton(container, 'Back');
+ expect(contextService.getContextValue(FOCUSING_COMMON_DRAWINGS)).toBe(false);
+ expect(container.querySelector('[aria-label="Open sheet tools"]')).not.toBeNull();
+ } finally {
+ disposeRenderedPanel(root, container, univer);
+ }
+ });
+
+ it('does not reopen the previous sheet drawer after drawing focus ends', async () => {
+ const { container, contextService, root, univer } = await renderMobileSheetActionPanel();
try {
clickButton(container, 'Open sheet tools');
@@ -246,7 +261,7 @@ describe('mobile sheet action panel visibility', () => {
}
});
- it('closes the sheet drawer after executing a nested insert menu command', () => {
+ it('closes the sheet drawer after executing a nested insert menu command', async () => {
const execute = vi.fn(() => true);
const ribbon: IMenuSchema[] = [{
key: RibbonPosition.INSERT,
@@ -274,7 +289,7 @@ describe('mobile sheet action panel visibility', () => {
}],
}],
}];
- const { commandService, container, root, univer } = renderMobileSheetActionPanel(ribbon);
+ const { commandService, container, root, univer } = await renderMobileSheetActionPanel(ribbon);
commandService.registerCommand({
id: TEST_INSERT_COMMAND_ID,
type: CommandType.COMMAND,
@@ -295,9 +310,9 @@ describe('mobile sheet action panel visibility', () => {
}
});
- it('closes the sheet drawer after selecting a detailed number format', () => {
+ it('closes the sheet drawer after selecting a detailed number format', async () => {
const execute = vi.fn(() => true);
- const { commandService, container, root, univer } = renderMobileSheetActionPanel(createNumberFormatRibbon());
+ const { commandService, container, root, univer } = await renderMobileSheetActionPanel(createNumberFormatRibbon());
commandService.registerCommand({
id: TEST_NUMFMT_COMMAND_ID,
type: CommandType.COMMAND,
@@ -317,9 +332,9 @@ describe('mobile sheet action panel visibility', () => {
}
});
- it('closes the sheet drawer after confirming a custom number format', () => {
+ it('closes the sheet drawer after confirming a custom number format', async () => {
const execute = vi.fn(() => true);
- const { commandService, container, root, univer } = renderMobileSheetActionPanel(createNumberFormatRibbon());
+ const { commandService, container, root, univer } = await renderMobileSheetActionPanel(createNumberFormatRibbon());
commandService.registerCommand({
id: TEST_NUMFMT_COMMAND_ID,
type: CommandType.COMMAND,
@@ -363,13 +378,6 @@ describe('mobile active-cell reveal offset', () => {
});
});
-describe('mobile editing menu placement', () => {
- it('moves above the compact formula operator strip while it is visible', () => {
- expect(getMobileEditingMenuBottomOffset(false)).toBe(72);
- expect(getMobileEditingMenuBottomOffset(true)).toBe(108);
- });
-});
-
describe('mobile style selection normalization', () => {
it('restores the last selection primary before running shared style commands', () => {
const selections = [
diff --git a/packages/sheets-ui/src/views/mobile/formula-bar/MobileFormulaBarControls.tsx b/packages/sheets-ui/src/views/mobile/formula-bar/MobileFormulaBarControls.tsx
index aadcf61e81..db75c48265 100644
--- a/packages/sheets-ui/src/views/mobile/formula-bar/MobileFormulaBarControls.tsx
+++ b/packages/sheets-ui/src/views/mobile/formula-bar/MobileFormulaBarControls.tsx
@@ -81,10 +81,8 @@ export function MobileFormulaBarOverlays(props: IMobileFormulaBarOverlayProps) {
dark:!univer-text-gray-100
dark:active:!univer-bg-primary-900
"
- onPointerDown={(event) => {
- event.preventDefault();
- event.stopPropagation();
- }}
+ onPointerDown={(event) => event.stopPropagation()}
+ onMouseDown={(event) => event.preventDefault()}
onClick={() => props.onOperator(operator.value)}
>
{operator.label}
@@ -160,7 +158,7 @@ export function MobileFormulaBarActions(props: IMobileFormulaBarActionProps) {
active:univer-scale-95 active:univer-bg-gray-100
dark:active:!univer-bg-gray-700
`, action.color)}
- onPointerDown={(event) => event.preventDefault()}
+ onMouseDown={(event) => event.preventDefault()}
onClick={action.onClick}
>
{action.icon}
diff --git a/packages/sheets-ui/src/views/permission/extensions/__tests__/range-protection.render.spec.ts b/packages/sheets-ui/src/views/permission/extensions/__tests__/range-protection.render.spec.ts
new file mode 100644
index 0000000000..1e4d84e06d
--- /dev/null
+++ b/packages/sheets-ui/src/views/permission/extensions/__tests__/range-protection.render.spec.ts
@@ -0,0 +1,76 @@
+/**
+ * Copyright 2023-present DreamNum Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import { Injector, ThemeService } from '@univerjs/core';
+import { Rect } from '@univerjs/engine-render';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import type { RangeProtectionRenderExtension } from '../range-protection.render';
+import { RangeProtectionCanNotViewRenderExtension, RangeProtectionCanViewRenderExtension } from '../range-protection.render';
+
+const EXTENSIONS: Array<new (theme: ThemeService) => RangeProtectionRenderExtension> = [RangeProtectionCanViewRenderExtension, RangeProtectionCanNotViewRenderExtension];
+
+describe('range protection assets', () => {
+ let image: HTMLImageElement;
+
+ beforeEach(() => {
+ vi.spyOn(HTMLImageElement.prototype, 'src', 'set').mockImplementation(function (this: HTMLImageElement) {
+ image = this;
+ });
+ });
+
+ afterEach(() => vi.restoreAllMocks());
+
+ it.each(EXTENSIONS)('invalidates cached protection pixels on load for %s', (Extension) => {
+ const injector = new Injector([
+ [ThemeService],
+ [Extension, { useFactory: (container: Injector, theme: ThemeService) => container.createInstance(Extension, theme), deps: [Injector, ThemeService] }],
+ ]);
+ const extension = injector.get(Extension);
+ const parent = injector.createInstance(Rect, 'protection-parent', {});
+ const dirty = vi.spyOn(parent, 'makeDirty');
+ extension.parent = parent;
+ try {
+ image.dispatchEvent(new Event('load'));
+ expect(dirty).toHaveBeenCalledExactlyOnceWith(true);
+ image.dispatchEvent(new Event('load'));
+ expect(dirty).toHaveBeenCalledOnce();
+ } finally {
+ extension.dispose();
+ parent.dispose();
+ injector.dispose();
+ }
+ });
+
+ it.each(EXTENSIONS)('disconnects pending protection image loads for %s', (Extension) => {
+ const injector = new Injector([
+ [ThemeService],
+ [Extension, { useFactory: (container: Injector, theme: ThemeService) => container.createInstance(Extension, theme), deps: [Injector, ThemeService] }],
+ ]);
+ const extension = injector.get(Extension);
+ const parent = injector.createInstance(Rect, 'disposed-protection-parent', {});
+ const dirty = vi.spyOn(parent, 'makeDirty');
+ extension.parent = parent;
+ extension.dispose();
+ try {
+ expect(image.onload).toBeNull();
+ image.dispatchEvent(new Event('load'));
+ expect(dirty).not.toHaveBeenCalled();
+ } finally {
+ parent.dispose();
+ injector.dispose();
+ }
+ });
+});
diff --git a/packages/sheets-ui/src/views/permission/extensions/__tests__/worksheet-permission.render.spec.ts b/packages/sheets-ui/src/views/permission/extensions/__tests__/worksheet-permission.render.spec.ts
new file mode 100644
index 0000000000..04389dcfca
--- /dev/null
+++ b/packages/sheets-ui/src/views/permission/extensions/__tests__/worksheet-permission.render.spec.ts
@@ -0,0 +1,73 @@
+/**
+ * Copyright 2023-present DreamNum Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import { Injector, ThemeService } from '@univerjs/core';
+import { Rect } from '@univerjs/engine-render';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { WorksheetProtectionRenderExtension } from '../worksheet-permission.render';
+
+describe('worksheet protection assets', () => {
+ let image: HTMLImageElement;
+
+ beforeEach(() => {
+ vi.spyOn(HTMLImageElement.prototype, 'src', 'set').mockImplementation(function (this: HTMLImageElement) {
+ image = this;
+ });
+ });
+
+ afterEach(() => vi.restoreAllMocks());
+
+ it.each([WorksheetProtectionRenderExtension])('invalidates cached protection pixels on load for %s', (Extension) => {
+ const injector = new Injector([
+ [ThemeService],
+ [Extension, { useFactory: (container: Injector, theme: ThemeService) => container.createInstance(Extension, theme), deps: [Injector, ThemeService] }],
+ ]);
+ const extension = injector.get(Extension);
+ const parent = injector.createInstance(Rect, 'protection-parent', {});
+ const dirty = vi.spyOn(parent, 'makeDirty');
+ extension.parent = parent;
+ try {
+ image.dispatchEvent(new Event('load'));
+ expect(dirty).toHaveBeenCalledExactlyOnceWith(true);
+ image.dispatchEvent(new Event('load'));
+ expect(dirty).toHaveBeenCalledOnce();
+ } finally {
+ extension.dispose();
+ parent.dispose();
+ injector.dispose();
+ }
+ });
+
+ it.each([WorksheetProtectionRenderExtension])('disconnects pending protection image loads for %s', (Extension) => {
+ const injector = new Injector([
+ [ThemeService],
+ [Extension, { useFactory: (container: Injector, theme: ThemeService) => container.createInstance(Extension, theme), deps: [Injector, ThemeService] }],
+ ]);
+ const extension = injector.get(Extension);
+ const parent = injector.createInstance(Rect, 'disposed-protection-parent', {});
+ const dirty = vi.spyOn(parent, 'makeDirty');
+ extension.parent = parent;
+ extension.dispose();
+ try {
+ expect(image.onload).toBeNull();
+ image.dispatchEvent(new Event('load'));
+ expect(dirty).not.toHaveBeenCalled();
+ } finally {
+ parent.dispose();
+ injector.dispose();
+ }
+ });
+});
diff --git a/packages/sheets-ui/src/views/permission/extensions/range-protection.render.ts b/packages/sheets-ui/src/views/permission/extensions/range-protection.render.ts
index bb20293422..5e06a701e8 100644
--- a/packages/sheets-ui/src/views/permission/extensions/range-protection.render.ts
+++ b/packages/sheets-ui/src/views/permission/extensions/range-protection.render.ts
@@ -43,6 +43,10 @@ export abstract class RangeProtectionRenderExtension extends SheetExtension {
shadowStrategy?: 'always' | 'non-editable' | 'non-viewable' | 'none'
) {
super();
+ this._img.onload = () => {
+ this._img.onload = null;
+ this.parent?.makeDirty(true);
+ };
this._img.src = base64;
if (shadowStrategy) {
this._shadowStrategy = shadowStrategy;
@@ -53,6 +57,13 @@ export abstract class RangeProtectionRenderExtension extends SheetExtension {
this.renderCache.clear();
}
+ override dispose(): void {
+ this._img.onload = null;
+ this._pattern = null;
+ this.renderCache.clear();
+ super.dispose();
+ }
+
/**
* Set the shadow strategy for this extension
* @param strategy The shadow strategy
@@ -125,6 +136,8 @@ export abstract class RangeProtectionRenderExtension extends SheetExtension {
}
export class RangeProtectionCanViewRenderExtension extends RangeProtectionRenderExtension {
+ override readonly viewportCacheReusable = this.constructor === RangeProtectionCanViewRenderExtension;
+
override uKey = RANGE_PROTECTION_CAN_VIEW_RENDER_EXTENSION_KEY;
override Z_INDEX = EXTENSION_CAN_VIEW_Z_INDEX;
@@ -147,6 +160,8 @@ export class RangeProtectionCanViewRenderExtension extends RangeProtectionRender
}
export class RangeProtectionCanNotViewRenderExtension extends RangeProtectionRenderExtension {
+ override readonly viewportCacheReusable = this.constructor === RangeProtectionCanNotViewRenderExtension;
+
override uKey = RANGE_PROTECTION_CAN_NOT_VIEW_RENDER_EXTENSION_KEY;
override Z_INDEX = EXTENSION_CAN_NOT_VIEW_Z_INDEX;
diff --git a/packages/sheets-ui/src/views/permission/extensions/worksheet-permission.render.ts b/packages/sheets-ui/src/views/permission/extensions/worksheet-permission.render.ts
index c966e487cd..b72c377579 100644
--- a/packages/sheets-ui/src/views/permission/extensions/worksheet-permission.render.ts
+++ b/packages/sheets-ui/src/views/permission/extensions/worksheet-permission.render.ts
@@ -26,6 +26,8 @@ const EXTENSION_CAN_VIEW_Z_INDEX = 25;
const EXTENSION_CAN_NOT_VIEW_Z_INDEX = 80;
export class WorksheetProtectionRenderExtension extends SheetExtension {
+ override readonly viewportCacheReusable = this.constructor === WorksheetProtectionRenderExtension;
+
override uKey = worksheetProtectionKey;
override Z_INDEX = EXTENSION_CAN_VIEW_Z_INDEX;
@@ -39,6 +41,10 @@ export class WorksheetProtectionRenderExtension extends SheetExtension {
shadowStrategy?: 'always' | 'non-editable' | 'non-viewable' | 'none'
) {
super();
+ this._img.onload = () => {
+ this._img.onload = null;
+ this.parent?.makeDirty(true);
+ };
this._img.src = base64;
if (shadowStrategy) {
this._shadowStrategy = shadowStrategy;
@@ -109,6 +115,12 @@ export class WorksheetProtectionRenderExtension extends SheetExtension {
ctx.restore();
}
+ override dispose(): void {
+ this._img.onload = null;
+ this._pattern = null;
+ super.dispose();
+ }
+
/**
* Set the shadow strategy for this extension
* @param strategy The shadow strategy
diff --git a/packages/ui/src/services/dom/canvas-dom-layer.service.ts b/packages/ui/src/services/dom/canvas-dom-layer.service.ts
index 30875fab4b..080dd7a1fd 100644
--- a/packages/ui/src/services/dom/canvas-dom-layer.service.ts
+++ b/packages/ui/src/services/dom/canvas-dom-layer.service.ts
@@ -48,6 +48,8 @@ export interface IFloatDom {
* forwarding by default; interactive embed runtimes can opt out.
*/
eventPassThrough?: boolean;
+ /** Cancel browser pinch/modified-wheel zoom while this host forwards events. */
+ preventBrowserZoom?: boolean;
/** Native listener options per event. Omitted events retain React forwarding. */
eventOptions?: Partial<Record<'wheel' | 'pointerdown' | 'pointermove' | 'pointerup', Pick<AddEventListenerOptions, 'passive' | 'capture'>>>;
/**
diff --git a/packages/ui/src/views/components/dom/FloatDom.tsx b/packages/ui/src/views/components/dom/FloatDom.tsx
index 8d586c994d..750199db48 100644
--- a/packages/ui/src/views/components/dom/FloatDom.tsx
+++ b/packages/ui/src/views/components/dom/FloatDom.tsx
@@ -15,13 +15,14 @@
*/
import type { ComponentType, CSSProperties } from 'react';
-import type { IFloatDom } from '../../../services/dom/canvas-dom-layer.service';
import { DocumentDataModel, IUniverInstanceService } from '@univerjs/core';
import { memo, useEffect, useMemo, useRef } from 'react';
import { first } from 'rxjs';
+import type { IFloatDom } from '../../../services/dom/canvas-dom-layer.service';
import { ComponentManager } from '../../../common/component-manager';
import { CanvasFloatDomService, shouldForwardFloatDomEvents, shouldRenderFloatDomLayer } from '../../../services/dom/canvas-dom-layer.service';
import { useDependency, useObservable } from '../../../utils/di';
+import { preventBrowserZoomInContainers } from '../../hooks/prevent-browser-zoom';
import { resolveFloatDomLayout } from './float-dom-layout';
function applyFloatDomLayout(
@@ -78,6 +79,13 @@ function FloatDomSingleContent(props: { layer: IFloatDom; id: string; Component?
const contentInset = layer.contentBox?.contentInset;
const forwardEvents = shouldForwardFloatDomEvents(layer);
+ useEffect(() => {
+ // React's passive wheel listener cannot cancel the native event copied to the host canvas.
+ if (forwardEvents && layer.preventBrowserZoom && domRef.current) {
+ return preventBrowserZoomInContainers([domRef.current]);
+ }
+ }, [forwardEvents, layer.preventBrowserZoom, position]);
+
useEffect(() => {
const subscription = layer.position$.subscribe((position) => {
if (domRef.current && innerDomRef.current) {
diff --git a/packages/ui/src/views/components/dom/__tests__/FloatDom.spec.tsx b/packages/ui/src/views/components/dom/__tests__/FloatDom.spec.tsx
index 9147ea2c1e..50ba63c7d7 100644
--- a/packages/ui/src/views/components/dom/__tests__/FloatDom.spec.tsx
+++ b/packages/ui/src/views/components/dom/__tests__/FloatDom.spec.tsx
@@ -32,7 +32,7 @@ import {
Workbook,
} from '@univerjs/core';
import { CanvasColorService, ICanvasColorService } from '@univerjs/engine-render';
-import { BehaviorSubject } from 'rxjs';
+import { BehaviorSubject, Subject } from 'rxjs';
import { afterEach, describe, expect, it, vi } from 'vitest';
import type { IFloatDom, IFloatDomLayout } from '../../../../services/dom/canvas-dom-layer.service';
import { ComponentManager } from '../../../../common/component-manager';
@@ -430,6 +430,74 @@ describe('FloatDomSingle', () => {
expect(onPointerDown).not.toHaveBeenCalled();
});
+ it.each(['ctrlKey', 'metaKey'] as const)('cancels native %s wheel zoom while forwarding the gesture once', async (modifier) => {
+ const onWheel = vi.fn();
+ const layer = { ...createFloatDom(), preventBrowserZoom: true, onWheel };
+ const rendered = renderWithDependencies(<FloatDomSingle id="dom-1" layer={layer} />);
+ try {
+ const inner = await waitFor(() => document.getElementById('dom-1') as HTMLDivElement);
+ const event = new WheelEvent('wheel', { bubbles: true, cancelable: true, deltaY: -20, [modifier]: true });
+ fireEvent(inner, event);
+ expect(event.defaultPrevented).toBe(true);
+ expect(onWheel).toHaveBeenCalledExactlyOnceWith(event);
+
+ onWheel.mockClear();
+ const scroll = new WheelEvent('wheel', { bubbles: true, cancelable: true, deltaY: 20 });
+ fireEvent(inner, scroll);
+ expect(scroll.defaultPrevented).toBe(false);
+ expect(onWheel).toHaveBeenCalledExactlyOnceWith(scroll);
+ } finally {
+ rendered.unmount();
+ rendered.injector.dispose();
+ }
+ });
+
+ it('releases zoom cancellation when a child owns events or the layer unmounts', async () => {
+ const rendered = renderWithDependencies(<FloatDom unitId="doc-1" />);
+ const service = rendered.injector.get(CanvasFloatDomService);
+ try {
+ act(() => service.addFloatDom({ ...createFloatDom(), preventBrowserZoom: true }));
+ const inner = await waitFor(() => document.getElementById('float-1') as HTMLDivElement);
+ const gesture = () => {
+ const event = new Event('gesturechange', { bubbles: true, cancelable: true });
+ fireEvent(inner, event);
+ return event.defaultPrevented;
+ };
+ expect(gesture()).toBe(true);
+ act(() => service.updateFloatDom('float-1', { preventBrowserZoom: false }));
+ expect(gesture()).toBe(false);
+ act(() => service.updateFloatDom('float-1', { preventBrowserZoom: true }));
+ expect(gesture()).toBe(true);
+ act(() => service.updateFloatDom('float-1', { eventPassThrough: false }));
+ expect(gesture()).toBe(false);
+ act(() => service.updateFloatDom('float-1', { eventPassThrough: true }));
+ expect(gesture()).toBe(true);
+ rendered.unmount();
+ expect(gesture()).toBe(false);
+ } finally {
+ rendered.unmount();
+ rendered.injector.dispose();
+ }
+ });
+
+ it('binds zoom cancellation after a delayed first position mounts the layer', async () => {
+ const position$ = new Subject<IFloatDomLayout>();
+ const initial = createFloatDom();
+ const rendered = renderWithDependencies(<FloatDomSingle id="dom-1" layer={{ ...initial, position$, preventBrowserZoom: true }} />);
+ try {
+ expect(document.getElementById('dom-1')).toBeNull();
+ act(() => position$.next((initial.position$ as BehaviorSubject<IFloatDomLayout>).value));
+ const inner = await waitFor(() => document.getElementById('dom-1') as HTMLDivElement);
+ const event = new Event('gesturestart', { bubbles: true, cancelable: true });
+ fireEvent(inner, event);
+ expect(event.defaultPrevented).toBe(true);
+ } finally {
+ rendered.unmount();
+ rendered.injector.dispose();
+ position$.complete();
+ }
+ });
+
it('updates clipped placement, full content size, and anchors through position$', async () => {
const position$ = createFloatDom().position$ as BehaviorSubject<IFloatDomLayout>;
const layer = { ...createFloatDom(), contentBox: { wrapperInset: 0, contentInset: 0 }, position$ };