diff --git a/docs/assets/guide/en/asd/Basic_Tutorial/Create_Instance.md b/docs/assets/guide/en/asd/Basic_Tutorial/Create_Instance.md index d3b084eda..63958527b 100644 --- a/docs/assets/guide/en/asd/Basic_Tutorial/Create_Instance.md +++ b/docs/assets/guide/en/asd/Basic_Tutorial/Create_Instance.md @@ -162,6 +162,8 @@ interface IStageParams { disableDirtyBounds: boolean; // Whether to support interactiveLayer, default is true interactiveLayer: boolean; + // Interactive layer mode; omitted uses the environment default. Virtual layers share the main canvas. + interactiveLayerMode?: 'static' | 'virtual'; // Whether to support HTML attributes enableHtmlAttribute: string | boolean | HTMLElement; // Whether to support react-dom (pass in ReactDOM) diff --git a/docs/assets/guide/en/asd/Basic_Tutorial/Event.md b/docs/assets/guide/en/asd/Basic_Tutorial/Event.md index 50b4f3ece..542db0618 100644 --- a/docs/assets/guide/en/asd/Basic_Tutorial/Event.md +++ b/docs/assets/guide/en/asd/Basic_Tutorial/Event.md @@ -122,3 +122,17 @@ window['stage'] = stage; ``` 【Note】: It is important to note that the event objects thrown by VRender are reusable, so be careful not to save event objects for later use, as the event object will change. This is particularly important to note in asynchronous processes. + +## Host-owned input and Stage composition + +Set `event: { useNativeEvents: false }` when the host owns DOM listeners. Route only accepted inputs through `stage.eventSystem.handleNativeEvent(nativeEvent, { canvasPoint: { x, y }, inViewport })`. The point uses logical canvas units after removing the host composition transform; do not scale it by DPR. EventSystem then applies the Stage window transform. Federated events already carry viewX/viewY, which Stage.eventPointTransform returns directly. Omitting options uses the default DOM mapping and viewport rules. + +Ignoring an input does not cancel a gesture. Call cancelPointer(pointerId), or cancelAllPointers(), when ownership changes. Cancellation clears pointer state before callbacks; reentrant new input is processed synchronously in FIFO order after the terminal transaction. Repeated cancellation is idempotent. + +`eventSystem.input.canvas` and `.window` expose on/off only. Both carry accepted Stage input, not unfiltered browser-window events. Dispatch order is scenegraph, window, canvas. Canvas out/leave describes logical viewport transitions, never sibling-mark transitions. An outside release emits one window pointerup and no canvas pointerup; the scenegraph retains pointerupoutside. Events are pooled: consume synchronously and save scalars for delayed work. + +Supported input types: pointerdown/move/up/cancel and wheel; mousedown/move/up (rightdown/rightup for the right button); touchstart/move/end/cancel; valid presses generate click/dblclick for mouse/pen, tap/dbltap when touch is supported, and pointertap. Canvas boundaries emit pointerover/enter/out/leave and corresponding mouse aliases. Do not forward native DOM click separately. stopPropagation does not control host authorization; cancel/release invalidate remaining normal dispatch. + +DataZoom and Slider subscribe to the accepted window scope and own one active pointer each. Cancellation keeps applied values and ends the gesture. DataZoom flushes the last accepted delayed move on normal up, discards pending moves on cancel, and commits its final value even with realTime=false. The DOM adapter preserves synchronous touch preventDefault; hosts own touch-action and scrolling policy. + +Use interactiveLayerMode:'virtual' to reuse the primary canvas. The interactive layer is prepared before the first draw and remains after business layers. Default layer selection and boolean interactiveLayer are preserved; false disables the layer. renderTo(window, rectangle?, options?) keeps its legacy second argument. Only explicit requestRender scheduling enables beforeRender/afterRender hooks in renderTo; default calls do not invoke new hooks. Its try/finally restores Stage state on failure without swallowing errors. diff --git a/docs/assets/guide/zh/asd/Basic_Tutorial/Create_Instance.md b/docs/assets/guide/zh/asd/Basic_Tutorial/Create_Instance.md index 28e4e66a5..4b70a58ab 100644 --- a/docs/assets/guide/zh/asd/Basic_Tutorial/Create_Instance.md +++ b/docs/assets/guide/zh/asd/Basic_Tutorial/Create_Instance.md @@ -162,6 +162,8 @@ interface IStageParams { disableDirtyBounds: boolean; // 是否支持interactiveLayer,默认为true interactiveLayer: boolean; + // 交互层模式;缺省沿用环境默认。virtual 复用主层 Canvas。 + interactiveLayerMode?: 'static' | 'virtual'; // 是否支持HTML属性 enableHtmlAttribute: string | boolean | HTMLElement; // 是否支持react-dom(传入ReactDOM) diff --git a/docs/assets/guide/zh/asd/Basic_Tutorial/Event.md b/docs/assets/guide/zh/asd/Basic_Tutorial/Event.md index f838815f7..ac4f8110a 100644 --- a/docs/assets/guide/zh/asd/Basic_Tutorial/Event.md +++ b/docs/assets/guide/zh/asd/Basic_Tutorial/Event.md @@ -122,3 +122,33 @@ window['stage'] = stage; ``` 【注意】:需要注意的是,VRender抛出的事件对象是复用的,所以注意不要保存事件对象在后续使用,因为事件对象会变的。这点在异步流程中需要特别注意 + +## 宿主输入与多 Stage 合成 + +默认 DOM 输入与宿主输入共用 EventSystem 的归一化、拾取和分发路径。宿主接入时关闭 Stage 的默认 DOM 监听: + +```ts +const stage = createStage({ + event: { useNativeEvents: false }, + interactiveLayerMode: 'virtual', + requestRender: () => scheduleHostFrame() +}); +// 先由宿主确定归属;canvasPoint 已去掉宿主合成矩阵,单位为逻辑像素,不乘 DPR。 +stage.eventSystem.handleNativeEvent(nativeEvent, { + canvasPoint: { x, y }, + inViewport: true +}); +// 忽略某一次输入不等于取消。切换所有权、宿主 blur 或开始其他手势时显式取消。 +stage.eventSystem.cancelPointer(pointerId); +stage.eventSystem.cancelAllPointers(); +``` + +坐标链为 client → 宿主 canvas 逻辑坐标 → 去掉宿主合成变换 → canvasPoint → Stage window.pointTransform → view。Stage.eventPointTransform 对 Federated 事件直接返回 viewX/viewY,不会重复解释 client 坐标。未传 options 的 handleNativeEvent 沿用 DOM 坐标与视口判断。 + +获准输入的两个订阅范围位于 `stage.eventSystem.input.canvas/window`,只暴露 on/off。window 是该 Stage 获准处理的输入,不是浏览器全窗口广播;canvas 只接收逻辑视口内输入。图元事件仍走 scenegraph,随后分发 window、canvas 输入源。图元间移动不会产生 canvas out/leave;跨逻辑视口才会。视口外的抬起在 window 发布一次 pointerup,在图元路径派生 pointerupoutside,不向 canvas 发布普通 up。 + +支持表:pointerdown/move/up/cancel、wheel;mouse 的 mousedown/move/up(右键 down/up 为 rightdown/rightup);touch 的 touchstart/move/end/cancel;有效按下/抬起产生 click/dblclick(mouse/pen)、tap/dbltap(支持 touch 时)、pointertap;canvas 边界产生 pointerover/enter/out/leave 及 mouse 对应别名。宿主不要再次转发浏览器 click。事件对象池化,只允许同步消费;异步处理保存所需标量,不能保存事件对象。stopPropagation 不改变宿主输入授权,cancel/release 会中止当前失效输入的后续正常分发。 + +取消先清 press/hover/click 状态,再通知消费者;重复取消不重复结束。取消回调里重新送入的输入在当前事务结束后同步按 FIFO 处理。DataZoom/Slider 每个组件只管理一个活动指针;取消保留最后已应用值并结束拖拽。DataZoom 正常 up 应用最后一次已接受的延迟 move,cancel 丢弃尚未应用的 move;realTime=false 仍发送终态。默认 DOM adapter 保持同步触摸 preventDefault;宿主接入自行决定 touch-action 与滚动策略。 + +virtual 交互 Layer 在第一次绘制准备前创建,保持位于业务 Layer 之后,复用主层 Canvas。默认 Layer 模式不变,interactiveLayer:false 优先禁用交互层。renderTo(window, rectangle?, options?) 保留第二参旧矩形契约,新合成选项在第三参。仅显式设置 requestRender 的宿主调度模式会在 renderTo 调用 beforeRender/afterRender;默认 renderTo 不新增 hook 调用。try/finally 只负责绘制异常时恢复 Stage 状态,不吞掉异常。 diff --git a/packages/vrender-components/__tests__/electron/host-input.test.ts b/packages/vrender-components/__tests__/electron/host-input.test.ts new file mode 100644 index 000000000..597e21abf --- /dev/null +++ b/packages/vrender-components/__tests__/electron/host-input.test.ts @@ -0,0 +1,9 @@ +import { runHostInputChecks } from '../util/host-input'; + +describe('host input and native virtual layers', () => { + it('keeps scoped input, cancellation, component drags and first-frame composition consistent', async () => { + const checks = await runHostInputChecks(); + expect(checks.length).toBeGreaterThan(40); + checks.forEach(check => expect(check.pass).toBe(true)); + }); +}); diff --git a/packages/vrender-components/__tests__/util/host-input.js b/packages/vrender-components/__tests__/util/host-input.js new file mode 100644 index 000000000..15ae82bce --- /dev/null +++ b/packages/vrender-components/__tests__/util/host-input.js @@ -0,0 +1,434 @@ +// Real Canvas/DOM regression fixture; shared by Electron and the source-browser verification. +import { createStage, createRect } from '@visactor/vrender'; +import { DataZoom } from '@visactor/vrender-components'; +import { loadBrowserEnv } from '@visactor/vrender-kits'; +import { vglobal } from '@visactor/vrender-core'; +import { Matrix } from '@visactor/vutils'; +import { Slider } from '@visactor/vrender-components'; +let results; +const check = (name, ok, detail) => { + results.push({ name, pass: !!ok, detail }); + if (!ok) throw Error(name + ': ' + JSON.stringify(detail)); +}; +function setup(component, defaults = false, extra = {}, defer = false) { + const canvas = document.createElement('canvas'); + document.body.appendChild(canvas); + const stage = createStage({ + canvas, + width: 400, + height: 180, + dpr: devicePixelRatio, + autoRender: false, + autoRefresh: false, + interactiveLayerMode: 'virtual', + event: { useNativeEvents: defaults }, + ...extra + }); + if (component) stage.defaultLayer.add(component); + if (!defer) stage.render(); + const sys = stage.eventSystem; + function send(type, x, y, id = 1, inside = true) { + const ev = new PointerEvent(type, { + clientX: x, + clientY: y, + pointerId: id, + pointerType: 'mouse', + button: 0, + buttons: type === 'pointerup' ? 0 : 1, + bubbles: true + }); + if (defaults) canvas.dispatchEvent(ev); + else sys.handleNativeEvent(ev, { canvasPoint: { x, y }, inViewport: inside }); + } + return { + stage, + sys, + send, + release() { + stage.release(); + canvas.remove(); + } + }; +} +function center(g) { + const b = g.globalAABBBounds; + return [(b.x1 + b.x2) / 2, (b.y1 + b.y2) / 2]; +} +function node(s, name) { + let found; + s.stage.find(g => { + if (g.name === name) found = g; + return false; + }, true); + return found; +} +export async function runHostInputChecks() { + results = []; + loadBrowserEnv(); + vglobal.setEnv('browser'); + // A clipped point must not trigger another scenegraph pick. + for (const affine of [false, true]) { + const rect = createRect({ x: 10, y: 10, width: 60, height: 60, fill: 'red' }); + const a = setup(rect); + const b = createRect({ x: 100, y: 10, width: 60, height: 60, fill: 'blue' }); + a.stage.defaultLayer.add(b); + a.stage.render(); + let hits = 0, + outsideMoves = 0, + leaves = 0; + for (const type of ['pointerover', 'pointerenter', 'pointermove', 'mousemove']) b.on(type, () => hits++); + rect.on('pointerout', () => leaves++); + a.sys.input.window.on('pointermove', () => outsideMoves++); + const send = (type, x, inside) => { + const client = affine ? { x: 1.5 * x + 46, y: 0.2 * x + 36 } : { x, y: 20 }; + a.sys.handleNativeEvent( + new PointerEvent(type, { + clientX: client.x, + clientY: client.y, + pointerId: 1, + pointerType: 'mouse', + buttons: 1 + }), + { canvasPoint: { x, y: 20 }, inViewport: inside } + ); + }; + send('pointermove', 20, true); + send('pointerdown', 20, true); + send('pointermove', 120, false); + check('host-clipped-target-' + affine, hits === 0 && outsideMoves === 2 && leaves === 1, { + hits, + outsideMoves, + leaves + }); + a.release(); + } + for (const capture of [true, false]) { + const rect = createRect({ x: 10, y: 10, width: 60, height: 60, fill: 'red' }); + const a = setup(rect); + let later = 0, + cancelled = 0, + scoped = 0; + const cancelOther = e => { + if (e.pointerId === 7) a.sys.cancelPointer(19); + }; + (capture ? a.stage : rect).addEventListener('pointerdown', cancelOther, capture); + rect.on('pointerdown', e => { + if (e.pointerId === 7) later++; + }); + a.sys.input.window.on('pointercancel', e => { + if (e.pointerId === 19) cancelled++; + }); + a.sys.input.window.on('pointerdown', e => { + if (e.pointerId === 7) scoped++; + }); + for (const id of [19, 7]) + a.sys.handleNativeEvent( + new PointerEvent('pointerdown', { + pointerId: id, + pointerType: 'touch', + clientX: 20, + clientY: 20, + buttons: 1 + }), + { canvasPoint: { x: 20, y: 20 }, inViewport: true } + ); + check('cancel-other-pointer-' + capture, later === 1 && cancelled === 1 && scoped === 1, { + later, + cancelled, + scoped + }); + a.release(); + } + for (const defaults of [false, true]) { + const a = setup(createRect({ x: 10, y: 10, width: 100, height: 100, fill: 'red' }), defaults); + let clicks = 0, + cancels = 0; + a.stage.on('click', () => clicks++); + a.stage.on('pointerdown', () => a.sys.cancelPointer(1)); + a.sys.input.window.on('pointercancel', () => cancels++); + a.send('pointerdown', 30, 30); + a.send('pointerup', 30, 30); + check('synchronous-cancel-' + defaults, clicks === 0 && cancels === 1, { clicks, cancels }); + a.release(); + } + for (const scope of ['target', 'capture', 'window', 'canvas']) { + const a = setup(createRect({ x: 10, y: 10, width: 100, height: 100, fill: 'red' })); + let down = 0, + click = 0, + alias = 0; + a.stage.on('click', () => click++); + a.sys.input.canvas.on('mousedown', () => alias++); + const rect = a.stage.defaultLayer.children[0]; + rect.on('pointerdown', () => down++); + if (scope === 'capture') a.stage.addEventListener('pointerdown', () => a.sys.cancelPointer(1), { capture: true }); + else if (scope === 'target') rect.on('pointerdown', () => a.sys.cancelPointer(1)); + else a.sys.input[scope].on('pointerdown', () => a.sys.cancelPointer(1)); + a.send('pointerdown', 30, 30); + a.send('pointerup', 30, 30); + check('cancel-' + scope, click === 0 && alias === 0 && (scope !== 'capture' || down === 0), { down, click, alias }); + a.release(); + } + { + const a = setup(createRect({ x: 10, y: 10, width: 100, height: 100, fill: 'red' })); + const order = []; + a.stage.on('pointerdown', () => order.push('down')); + a.stage.on('pointercancel', () => { + order.push('cancel'); + a.send('pointerdown', 30, 30); + }); + a.sys.input.window.on('pointercancel', () => order.push('window-cancel')); + a.send('pointerdown', 30, 30); + a.sys.cancelPointer(1); + check('cancel-reentrant-down', order.join(',') === 'down,cancel,window-cancel,down', order); + a.stage.removeAllListeners(); + a.release(); + } + { + const a = setup(createRect({ x: 10, y: 10, width: 100, height: 100, fill: 'red' })); + let w = 0, + c = 0, + click = 0; + a.sys.input.window.on('pointerup', () => w++); + a.sys.input.canvas.on('pointerup', () => c++); + a.stage.on('click', () => click++); + a.send('pointerdown', 30, 30); + a.send('pointerup', 450, 30, 1, false); + check('outside-up', w === 1 && c === 0 && click === 0, { w, c, click }); + a.release(); + } + for (const kind of ['zoom', 'slider']) + for (const delay of kind === 'zoom' ? [0, 30] : [0]) + for (const cancel of [false, true]) { + const component = + kind === 'zoom' + ? new DataZoom({ + position: { x: 30, y: 30 }, + size: { width: 300, height: 50 }, + start: 0.2, + end: 0.8, + realTime: true, + delayType: 'debounce', + delayTime: delay + }) + : new Slider({ x: 30, y: 30, min: 0, max: 100, value: 20, railWidth: 300, railHeight: 10 }); + const a = setup(component); + const all = []; + a.stage.find(g => { + if (g.name) all.push(g.name); + return false; + }, true); + const target = kind === 'zoom' ? node(a, 'startHandlerMask') : node(a, 'sliderStartHandler'); + if (!target) throw Error('missing ' + kind + JSON.stringify(all)); + const pos = center(target); + a.send('pointerdown', ...pos); + a.send('pointermove', pos[0] + 30, pos[1]); + if (cancel) a.sys.cancelPointer(1); + else a.send('pointerup', pos[0] + 100, pos[1]); + const value = kind === 'zoom' ? component._state.start : component.currentValue.startValue; + await new Promise(r => setTimeout(r, 60)); + const after = kind === 'zoom' ? component._state.start : component.currentValue.startValue; + a.send('pointermove', pos[0] + 150, pos[1]); + a.send('pointerup', pos[0] + 150, pos[1]); + const late = kind === 'zoom' ? component._state.start : component.currentValue.startValue; + check( + `${kind}-${delay}-${cancel}`, + value === after && + after === late && + (cancel && delay ? Math.abs(value - 0.2) < 0.001 : value > (kind === 'zoom' ? 0.2 : 20)), + { value, after, late } + ); + a.release(); + } + + // Logical canvas scope must not follow scenegraph sibling boundaries. + { + const a = setup(createRect({ x: 10, y: 10, width: 30, height: 30, fill: 'red' })); + a.stage.defaultLayer.add(createRect({ x: 70, y: 10, width: 30, height: 30, fill: 'blue' })); + a.stage.render(); + let leaves = 0, + enters = 0, + clicks = 0, + doubles = 0; + a.sys.input.canvas.on('pointerout', () => leaves++); + a.sys.input.canvas.on('pointerover', () => enters++); + a.sys.input.canvas.on('click', () => clicks++); + a.sys.input.canvas.on('dblclick', () => doubles++); + a.send('pointermove', 20, 20); + a.send('pointermove', 80, 20); + check('sibling-is-not-canvas-leave', leaves === 0 && enters === 1, { leaves, enters }); + a.send('pointermove', 450, 20, 1, false); + check('logical-leave', leaves === 1, { leaves }); + a.send('pointerdown', 200, 100); + a.send('pointerup', 200, 100); + a.send('pointerdown', 200, 100); + a.send('pointerup', 200, 100); + check('blank-canvas-click', clicks === 2 && doubles === 1, { clicks, doubles }); + a.release(); + } + for (const realTime of [true, false]) + for (const action of ['up', 'cancel', 'outside-cancel', 'release', 'delay-change']) { + const c = new DataZoom({ + position: { x: 30, y: 30 }, + size: { width: 300, height: 50 }, + start: 0.2, + end: 0.8, + realTime, + delayType: 'debounce', + delayTime: 30 + }); + const a = setup(c), + pos = center(node(a, 'startHandlerMask')); + a.send('pointerdown', ...pos); + a.send('pointermove', pos[0] + 30, pos[1]); + a.send('pointermove', pos[0] + 150, pos[1], 2); + if (action === 'up') a.send('pointerup', pos[0] + 100, pos[1]); + if (action === 'cancel') a.sys.cancelPointer(1); + if (action === 'outside-cancel') { + a.stage.on('pointerupoutside', () => a.sys.cancelPointer(1)); + a.send('pointerup', 450, 30, 1, false); + } + if (action === 'release') c.release(); + if (action === 'delay-change') c.setAttributes({ delayTime: 60 }); + await new Promise(r => setTimeout(r, 80)); + check( + 'debounce-' + realTime + '-' + action, + action === 'up' ? c._state.start > 0.2 && c._state.start < 0.4 : c._state.start === 0.2, + { value: c._state.start } + ); + a.release(); + } + for (const kind of ['zoom', 'slider']) { + const c = + kind === 'zoom' + ? new DataZoom({ position: { x: 30, y: 30 }, size: { width: 300, height: 50 }, start: 0.2, end: 0.8 }) + : new Slider({ + x: 30, + y: 30, + min: 0, + max: 100, + value: [20, 70], + range: { draggableTrack: true }, + railWidth: 300, + railHeight: 10 + }); + const a = setup(c), + pos = center(node(a, kind === 'zoom' ? 'startHandlerMask' : 'sliderTrack')); + const value = () => (kind === 'zoom' ? c._state.start : c.currentValue.startValue); + const before = value(); + a.send('pointerdown', ...pos); + a.send('pointermove', pos[0] + 30, pos[1], 2); + check(kind + '-foreign-pointer', value() === before); + a.send('pointermove', pos[0] + 30, pos[1]); + const moved = value(); + check(kind + '-drag', moved > before, { moved, before }); + a.sys.cancelPointer(1); + a.send('pointermove', pos[0] + 70, pos[1]); + check(kind + '-cancel-keeps-value', value() === moved); + a.send('pointerdown', ...center(node(a, kind === 'zoom' ? 'startHandlerMask' : 'sliderTrack'))); + a.send('pointermove', pos[0] + 90, pos[1]); + a.send('pointerup', pos[0] + 90, pos[1]); + check(kind + '-restart', value() > moved, { value: value(), moved }); + a.release(); + } + // Both coordinate consumers must read view coordinates after host inverse and Stage transform. + for (const matrix of [new Matrix(1, 0, 0, 1, 40, 20), new Matrix(1.5, 0.2, 0.3, 0.8, 40, 20)]) { + const a = setup(createRect({ x: 10, y: 10, width: 100, height: 100, fill: 'red' })); + a.stage.window.setViewBoxTransform(2, 0, 0, 2, 0, 0); + let point; + a.stage.on('pointerdown', e => (point = [e.viewX, e.viewY, ...Object.values(a.stage.eventPointTransform(e))])); + const local = { x: 40, y: 40 }, + client = { + x: matrix.a * local.x + matrix.c * local.y + matrix.e, + y: matrix.b * local.x + matrix.d * local.y + matrix.f + }; + const canvasPoint = { x: 0, y: 0 }; + matrix.transformPoint(client, canvasPoint); + a.sys.handleNativeEvent( + new PointerEvent('pointerdown', { clientX: client.x, clientY: client.y, pointerId: 1, pointerType: 'mouse' }), + { canvasPoint, inViewport: true } + ); + check( + 'mapped-stage-component-point', + point?.every(v => Math.abs(v - 20) < 0.001), + point + ); + a.release(); + } + // First normal frame and composition frame, later source Layer, runtime Layer insertion, hooks. + for (const route of ['render', 'frame', 'renderTo']) { + const a = setup(null, false, { background: 'transparent' }, true), + target = setup(null, false, { background: 'transparent' }); + const later = a.stage.createLayer(undefined, 'virtual'); + const raised = createRect({ x: 20, y: 20, width: 50, height: 50, fill: 'red', globalZIndex: 1 }); + later.add(raised); + const b = a.stage.createLayer(undefined, 'virtual'); + b.add(createRect({ x: 20, y: 20, width: 50, height: 50, fill: 'blue' })); + const paint = () => { + if (route === 'render') a.stage.render(); + else if (route === 'frame') { + a.stage.renderNextFrame(); + a.stage._doRenderInThisFrame(); + } else a.stage.renderTo(target.stage.window, undefined, { clear: false }); + }; + paint(); + const canvas = (route === 'renderTo' ? target : a).stage.window.getNativeHandler().nativeCanvas; + const pixel = () => + Array.from(canvas.getContext('2d').getImageData(40 * devicePixelRatio, 40 * devicePixelRatio, 1, 1).data); + check('virtual-first-' + route, pixel()[0] === 255 && pixel()[2] === 0, pixel()); + const top = a.stage.createLayer(undefined, 'virtual'); + top.add(createRect({ x: 20, y: 20, width: 50, height: 50, fill: 'green' })); + paint(); + check('virtual-dynamic-' + route, pixel()[0] === 255 && pixel()[1] === 0, pixel()); + a.release(); + target.release(); + } + for (const hosted of [false, true]) { + const a = setup(null, false, hosted ? { requestRender: () => {} } : {}), + target = setup(); + let before = 0, + after = 0; + a.stage.hooks.beforeRender.tap('test', () => { + before++; + const layer = a.stage.createLayer(undefined, 'virtual'); + layer.add(createRect({ x: 10, y: 10, width: 20, height: 20, fill: 'red', globalZIndex: 1 })); + }); + a.stage.hooks.afterRender.tap('test', () => after++); + a.stage.renderTo(target.stage.window); + check('renderTo-hooks-' + hosted, before === (hosted ? 1 : 0) && after === (hosted ? 1 : 0), { before, after }); + if (hosted) { + a.stage.hooks.beforeRender.tap('error', () => { + throw Error('test'); + }); + try { + a.stage.renderTo(target.stage.window); + } catch {} + check('renderTo-restores-state', a.stage.state === 'normal', a.stage.state); + } + a.release(); + target.release(); + } + { + const a = setup(createRect({ x: 10, y: 10, width: 100, height: 100, fill: 'red' })); + const order = []; + let restarting = false; + a.stage.on('pointerdown', () => { + if (restarting) { + order.push('down'); + a.send('pointermove', 30, 30); + } + }); + a.stage.on('pointerup', () => order.push('up')); + a.stage.on('pointermove', () => order.push('move')); + a.stage.on('pointercancel', () => { + restarting = true; + a.send('pointerdown', 30, 30); + a.send('pointerup', 30, 30); + }); + a.send('pointerdown', 30, 30); + a.sys.cancelPointer(1); + check('cancel-drain-fifo', order.join(',') === 'down,up,move', order); + a.stage.removeAllListeners(); + a.release(); + } + return results; +} diff --git a/packages/vrender-components/src/data-zoom/data-zoom.ts b/packages/vrender-components/src/data-zoom/data-zoom.ts index 878852fb6..39595942c 100644 --- a/packages/vrender-components/src/data-zoom/data-zoom.ts +++ b/packages/vrender-components/src/data-zoom/data-zoom.ts @@ -196,8 +196,8 @@ export class DataZoom extends AbstractComponent> { /** * 浏览器上的事件必须解绑,防止内存泄漏,场景树上的事件会自动解绑 */ - super.release(all); this._interaction.clearDragEvents(); + super.release(all); } /** 外部重置组件的起始状态 */ diff --git a/packages/vrender-components/src/data-zoom/interaction.ts b/packages/vrender-components/src/data-zoom/interaction.ts index 98a650be1..d26b68fa4 100644 --- a/packages/vrender-components/src/data-zoom/interaction.ts +++ b/packages/vrender-components/src/data-zoom/interaction.ts @@ -1,8 +1,6 @@ import { DataZoomActiveTag, IDataZoomInteractiveEvent, type DataZoomAttributes } from './type'; -import { getEndTriggersOfDrag } from '../util/event'; import type { IPointLike, Dict, Matrix } from '@visactor/vutils'; -import { vglobal } from '@visactor/vrender-core'; -import type { FederatedPointerEvent, IGroup, IRect, ISymbol, IStage } from '@visactor/vrender-core'; +import type { FederatedPointerEvent, InputEventSource, IGroup, IRect, ISymbol, IStage } from '@visactor/vrender-core'; import { clamp, debounce, EventEmitter, throttle } from '@visactor/vutils'; const delayMap = { debounce: debounce, @@ -65,19 +63,32 @@ export class DataZoomInteraction extends EventEmitter { }; private _spanCache: number; - private _onHandlerPointerMove: (e: FederatedPointerEvent) => void; + private _inputSource?: InputEventSource; + private _activePointerId?: number; + private _finishing = false; + private _pending = false; + private _pendingPoint = { x: 0, y: 0 }; + private _scheduleMove: (() => void) & { cancel?: () => void }; + private _delayTime = 0; + private _delayType = 'debounce'; constructor(props: InteractionAttributes) { super(); - this._initAttrs(props); + this._scheduleMove = this._applyPendingPoint; + this.setAttributes(props); } setAttributes(props: InteractionAttributes): void { + const delayTime = props.attribute.delayTime ?? 0; + const delayType = props.attribute.delayType ?? 'debounce'; + if (delayTime !== this._delayTime || delayType !== this._delayType) { + this.clearDragEvents(); + this._delayTime = delayTime; + this._delayType = delayType; + this._scheduleMove = + delayTime === 0 ? this._applyPendingPoint : delayMap[delayType](this._applyPendingPoint, delayTime); + } this._initAttrs(props); - this._onHandlerPointerMove = - (this.attribute?.delayTime ?? 0) === 0 - ? this._pointerMove - : delayMap[this.attribute?.delayType ?? 'debounce'](this._pointerMove, this.attribute?.delayTime ?? 0); } private _initAttrs(props: InteractionAttributes) { @@ -105,23 +116,14 @@ export class DataZoomInteraction extends EventEmitter { } clearDragEvents() { - const evtTarget = vglobal.env === 'browser' ? vglobal : this.stage; - const triggers = getEndTriggersOfDrag(); - - evtTarget.removeEventListener('pointermove', this._onHandlerPointerMove, { capture: true }); - triggers.forEach((trigger: string) => { - evtTarget.removeEventListener(trigger, this._onHandlerPointerUp); - }); - - (this as unknown as IGroup).off('pointermove', this._onHandlerPointerMove, { - capture: true - }); - } - - clearVGlobalEvents() { - (vglobal.env === 'browser' ? vglobal : this.stage).removeEventListener('touchmove', this._handleTouchMove, { - passive: false - }); + this._scheduleMove?.cancel?.(); + this._pending = false; + this._inputSource?.off('pointermove', this._onHandlerPointerMove); + this._inputSource?.off('pointerup', this._onHandlerPointerUp); + this._inputSource?.off('pointercancel', this._onHandlerPointerCancel); + this._inputSource = undefined; + this._activePointerId = undefined; + this._activeState = false; } bindEvents(): void { @@ -162,29 +164,18 @@ export class DataZoomInteraction extends EventEmitter { 'pointerdown', (e: FederatedPointerEvent) => this._onHandlerPointerDown(e, selectedTag) as unknown as EventListener ); - - (vglobal.env === 'browser' ? vglobal : this.stage).addEventListener('touchmove', this._handleTouchMove, { - passive: false - }); } - private _handleTouchMove = (e: TouchEvent) => { - if (this._activeState) { - /** - * https://developer.mozilla.org/zh-CN/docs/Web/CSS/overscroll-behavior - * 由于浏览器的overscroll-behavior属性,需要在move的时候阻止浏览器默认行为,否则会因为浏览器检测到scroll行为,阻止pointer事件, - * 抛出pointercancel事件,导致拖拽行为中断。 - */ - e.preventDefault(); - } - }; /** * 拖拽开始事件 * @description 开启activeState + 通过tag判断事件在哪个元素上触发 并 更新交互坐标 */ private _onHandlerPointerDown = (e: FederatedPointerEvent, tag: string) => { - // 清除之前的事件,防止没有被清除掉 + if (this._activeState || this._finishing) { + return; + } this.clearDragEvents(); + this._activePointerId = e.pointerId; if (tag === 'start') { this._activeTag = DataZoomActiveTag.startHandler; this._activeItem = this._startHandlerMask; @@ -204,20 +195,10 @@ export class DataZoomInteraction extends EventEmitter { this._activeState = true; this._activeCache.startPos = this._eventPosToStagePos(e); this._activeCache.lastPos = this._eventPosToStagePos(e); - const evtTarget = vglobal.env === 'browser' ? vglobal : this.stage; - const triggers = getEndTriggersOfDrag(); - - /** - * move的时候,需要通过 capture: true,能够在捕获截断被拦截, - */ - evtTarget.addEventListener('pointermove', this._onHandlerPointerMove, { capture: true }); - (this as unknown as IGroup).on('pointermove', this._onHandlerPointerMove, { - capture: true - }); - - triggers.forEach((trigger: string) => { - evtTarget.addEventListener(trigger, this._onHandlerPointerUp); - }); + this._inputSource = this.stage.eventSystem.input.window; + this._inputSource.on('pointermove', this._onHandlerPointerMove); + this._inputSource.on('pointerup', this._onHandlerPointerUp); + this._inputSource.on('pointercancel', this._onHandlerPointerCancel); }; /** @@ -228,10 +209,29 @@ export class DataZoomInteraction extends EventEmitter { * 3. 在startHandler上拖拽 (activeTag === 'startHandler'): 改变lastPos、start & end + 边界处理: startHandler和endHandler交换 => render * 4. 在endHandler上拖拽,同上 */ - private _pointerMove = (e: FederatedPointerEvent) => { + private _onHandlerPointerMove = (e: FederatedPointerEvent) => { + if (e.pointerId !== this._activePointerId || this._finishing) { + return; + } + if (e.pointerType === 'touch') { + e.preventDefault(); + } + this._eventPosToStagePos(e, this._pendingPoint); + this._pending = true; + this._scheduleMove(); + }; + + private _applyPendingPoint = () => { + if (!this._pending || !this._activeState) { + return; + } + this._pending = false; + this._pointerMove(this._pendingPoint); + }; + + private _pointerMove = (pos: IPointLike) => { const { brushSelect } = this.attribute as DataZoomAttributes; const { position } = this._getLayoutAttrFromConfig(); - const pos = this._eventPosToStagePos(e); const { attPos, size, attSize } = this._layoutCache; const dis = (pos[attPos] - this._activeCache.lastPos[attPos]) / size; @@ -251,7 +251,8 @@ export class DataZoomInteraction extends EventEmitter { shouldRender = false; this._dispatchEvent(IDataZoomInteractiveEvent.maskUpdate); } - this._activeCache.lastPos = pos; + this._activeCache.lastPos.x = pos.x; + this._activeCache.lastPos.y = pos.y; } // 避免attributes相同时, 重复渲染 @@ -353,36 +354,42 @@ export class DataZoomInteraction extends EventEmitter { * 拖拽结束事件 * @description 关闭activeState + 边界情况处理: 防止拖拽后start和end过近 */ - private _onHandlerPointerUp = (e: FederatedPointerEvent) => { - if (this._activeState) { - // brush的时候, 只改变了state, 没有触发重新渲染, 在抬起鼠标时触发 - if (this._activeTag === DataZoomActiveTag.background) { - this._setStateAttr(this._getState().start, this._getState().end); + private _onHandlerPointerUp = (e: FederatedPointerEvent) => this._finish(e, false); + private _onHandlerPointerCancel = (e: FederatedPointerEvent) => this._finish(e, true); + + private _finish(e: FederatedPointerEvent, cancel: boolean): void { + if (e.pointerId !== this._activePointerId || this._finishing) { + return; + } + this._finishing = true; + try { + this._scheduleMove.cancel?.(); + if (!cancel) { + this._applyPendingPoint(); + } + const tag = this._activeTag; + this.clearDragEvents(); + if (tag === DataZoomActiveTag.background) { this._dispatchEvent(IDataZoomInteractiveEvent.stateUpdate, { - start: this._getState().start, - end: this._getState().end, + ...this._getState(), shouldRender: true, - tag: this._activeTag + tag }); } + // Cancellation retains applied values; delayed samples are discarded. realTime=false still commits. + this._dispatchEvent(IDataZoomInteractiveEvent.dataZoomUpdate, { + ...this._getState(), + shouldRender: true, + tag + }); + } finally { + this.clearDragEvents(); + this._finishing = false; } - this._activeState = false; - // 此次dispatch不能被省略 - // 因为pointermove时, 已经将状态更新至最新, 所以在pointerup时, 必定start = state.start & end = state.end - // 而realTime = false时, 需要依赖这次dispatch来更新图表图元 - this._dispatchEvent(IDataZoomInteractiveEvent.dataZoomUpdate, { - start: this._getState().start, - end: this._getState().end, - shouldRender: true, - tag: this._activeTag - }); - - this.clearDragEvents(); - }; + } /** 事件系统坐标转换为stage坐标 */ - private _eventPosToStagePos(e: FederatedPointerEvent) { - const result = { x: 0, y: 0 }; + private _eventPosToStagePos(e: FederatedPointerEvent, result = { x: 0, y: 0 }) { // 1. 外部坐标 -> 内部坐标 const stagePoints = this.stage?.eventPointTransform(e as any) ?? { x: 0, y: 0 }; // updateSpec过程中交互的话, stage可能为空 // 2. 内部坐标 -> 组件坐标 (比如: 给layer设置 scale / x / y) diff --git a/packages/vrender-components/src/slider/slider.ts b/packages/vrender-components/src/slider/slider.ts index f07a5d889..f5e6c3efc 100644 --- a/packages/vrender-components/src/slider/slider.ts +++ b/packages/vrender-components/src/slider/slider.ts @@ -12,6 +12,7 @@ import type { IText, ITextGraphicAttribute, FederatedPointerEvent, + InputEventSource, Cursor } from '@visactor/vrender-core'; import { @@ -26,7 +27,7 @@ import { debounce, isFunction } from '@visactor/vutils'; -import { vglobal, CustomEvent } from '@visactor/vrender-core'; +import { CustomEvent } from '@visactor/vrender-core'; import { graphicCreator } from '../util/graphic-creator'; import { AbstractComponent } from '../core/base'; import { SLIDER_ELEMENT_NAME } from './constant'; @@ -34,7 +35,6 @@ import { SLIDER_ELEMENT_NAME } from './constant'; import type { SliderAttributes } from './type'; import type { ComponentOptions } from '../interface'; import { loadSliderComponent } from './register'; -import { getEndTriggersOfDrag } from '../util/event'; function convertValueToRange(value: number | [number, number]) { if (isArray(value)) { @@ -660,8 +660,8 @@ export class Slider extends AbstractComponent> { text: textConfig.formatter ? textConfig.formatter(this._tooltipState.value) : !this._isHorizontal && align === 'left' - ? `${this._tooltipState.value.toFixed(textConfig.precision ?? 0)} ≈` - : `≈ ${this._tooltipState.value.toFixed(textConfig.precision ?? 0)}` + ? `${this._tooltipState.value.toFixed(textConfig.precision ?? 0)} ≈` + : `≈ ${this._tooltipState.value.toFixed(textConfig.precision ?? 0)}` }); } } @@ -708,9 +708,6 @@ export class Slider extends AbstractComponent> { /** * move的时候,需要显示的设置passive: false,因为在移动端需要禁用浏览器默认行为 */ - (vglobal.env === 'browser' ? vglobal : this.stage).addEventListener('touchmove', this._handleTouchMove, { - passive: false - }); } } @@ -779,40 +776,47 @@ export class Slider extends AbstractComponent> { this._dispatchTooltipEvent('sliderTooltipHide'); }; + private _inputSource?: InputEventSource; + private _activePointerId?: number; + private _onHandlerPointerdown = (e: FederatedPointerEvent) => { + if (this._activePointerId !== undefined) { + return; + } this._clearAllDragEvents(); + this._activePointerId = e.pointerId; this._isChanging = true; const { x, y } = this.stage.eventPointTransform(e); this._currentHandler = e.target as unknown as IGraphic; this._prePos = this._isHorizontal ? x : y; - const triggers = getEndTriggersOfDrag(); - const obj = vglobal.env === 'browser' ? vglobal : this.stage; - - /** - * move的时候,需要通过 capture: true,能够在捕获截断被拦截 - */ - obj.addEventListener('pointermove', this._onHandlerPointerMove, { capture: true }); - triggers.forEach((trigger: string) => { - obj.addEventListener(trigger, this._onHandlerPointerUp); - }); + this._bindDragEvents(this._onHandlerPointerMove); }; - private _clearAllDragEvents() { - const triggers = getEndTriggersOfDrag(); - const obj = vglobal.env === 'browser' ? vglobal : this.stage; - - obj.removeEventListener('pointermove', this._onHandlerPointerMove, { capture: true }); - triggers.forEach((trigger: string) => { - obj.removeEventListener(trigger, this._onHandlerPointerUp); - }); + private _bindDragEvents(move: (e: FederatedPointerEvent) => void): void { + this._inputSource = this.stage.eventSystem.input.window; + this._inputSource.on('pointermove', move); + this._inputSource.on('pointerup', this._onHandlerPointerUp); + this._inputSource.on('pointercancel', this._onHandlerPointerUp); + } - obj.removeEventListener('pointermove', this._onTrackPointerMove, { capture: true }); - triggers.forEach((trigger: string) => { - obj.removeEventListener(trigger, this._onTrackPointerUp); - }); + private _clearAllDragEvents() { + this._inputSource?.off('pointermove', this._onHandlerPointerMove); + this._inputSource?.off('pointermove', this._onTrackPointerMove); + this._inputSource?.off('pointerup', this._onHandlerPointerUp); + this._inputSource?.off('pointercancel', this._onHandlerPointerUp); + this._inputSource = undefined; + this._activePointerId = undefined; + this._isChanging = false; + this._currentHandler = null; } private _onHandlerPointerMove = (e: FederatedPointerEvent) => { + if (e.pointerId !== this._activePointerId) { + return; + } + if (e.pointerType === 'touch') { + e.preventDefault(); + } this._isChanging = true; const { railWidth, railHeight, min, max } = this.attribute as SliderAttributes; if (max === min) { @@ -852,39 +856,36 @@ export class Slider extends AbstractComponent> { }; private _onHandlerPointerUp = (e: FederatedPointerEvent) => { + if (e.pointerId !== this._activePointerId) { + return; + } this._isChanging = false; this._currentHandler = null; this._clearAllDragEvents(); }; - private _handleTouchMove = (e: TouchEvent) => { - if (this._isChanging) { - /** - * https://developer.mozilla.org/zh-CN/docs/Web/CSS/overscroll-behavior - * 由于浏览器的overscroll-behavior属性,需要在move的时候阻止浏览器默认行为,否则会因为浏览器检测到scroll行为,阻止pointer事件, - * 抛出pointercancel事件,导致拖拽行为中断。 - */ - e.preventDefault(); - } - }; - private _onTrackPointerdown = (e: FederatedPointerEvent) => { + e.stopPropagation(); + if (this._activePointerId !== undefined) { + return; + } this._clearAllDragEvents(); + this._activePointerId = e.pointerId; this._isChanging = true; const { x, y } = this.stage.eventPointTransform(e); this._prePos = this._isHorizontal ? x : y; - const triggers = getEndTriggersOfDrag(); - const obj = vglobal.env === 'browser' ? vglobal : this.stage; - - obj.addEventListener('pointermove', this._onTrackPointerMove, { capture: true }); - triggers.forEach((trigger: string) => { - obj.addEventListener(trigger, this._onTrackPointerUp); - }); + this._bindDragEvents(this._onTrackPointerMove); }; private _onTrackPointerMove = (e: FederatedPointerEvent) => { + if (e.pointerId !== this._activePointerId) { + return; + } + if (e.pointerType === 'touch') { + e.preventDefault(); + } this._isChanging = true; const { railWidth, railHeight, min, max, inverse } = this.attribute as SliderAttributes; @@ -945,15 +946,11 @@ export class Slider extends AbstractComponent> { this._dispatchChangeEvent(); }; - private _onTrackPointerUp = (e: FederatedPointerEvent) => { - this._isChanging = false; - - this._clearAllDragEvents(); - }; - private _onRailPointerDown = (e: FederatedPointerEvent) => { + if (this._activePointerId !== undefined) { + return; + } this._clearAllDragEvents(); - this._isChanging = true; const { railWidth, railHeight, min, max } = this.attribute as SliderAttributes; if (max === min) { @@ -1160,10 +1157,7 @@ export class Slider extends AbstractComponent> { /** * 浏览器上的事件必须解绑,防止内存泄漏,场景树上的事件会自动解绑 */ - super.release(all); - (vglobal.env === 'browser' ? vglobal : this.stage).removeEventListener('touchmove', this._handleTouchMove, { - passive: false - }); this._clearAllDragEvents(); + super.release(all); } } diff --git a/packages/vrender-core/__tests__/types/stage-api.ts b/packages/vrender-core/__tests__/types/stage-api.ts new file mode 100644 index 000000000..aeead5ec5 --- /dev/null +++ b/packages/vrender-core/__tests__/types/stage-api.ts @@ -0,0 +1,32 @@ +import type { IStage, IStageParams, IWindow } from '../../src/interface'; +import type { Stage } from '../../src/core/stage'; + +// Compile-only regression: preserve boolean consumers, legacy object literals/variables/callbacks, +// and both the public interface and concrete Stage entrypoints. +export function stageApiCompatibility(stage: IStage, concrete: Stage, target: IWindow, options: IStageParams) { + const enabled: boolean = options.interactiveLayer; + const legacy = { x: 10, y: 20, width: 30, height: 40 }; + stage.renderTo(target, { x: 10, y: 20, width: 30, height: 40 }); + stage.renderTo(target, legacy); + concrete.renderTo(target); + concrete.renderTo(target, legacy); + const callback: (window: IWindow, params: typeof legacy) => void = stage.renderTo; + callback(target, legacy); + stage.renderTo(target); + stage.renderTo(target, undefined, { clear: false }); + stage.renderTo(target, legacy, { clear: false }); + concrete.renderTo(target, undefined, { clear: false }); + concrete.renderTo(target, legacy, { clear: false }); + // @ts-expect-error New drawing options must not change the legacy rectangle argument. + stage.renderTo(target, { clear: false }); + // @ts-expect-error Legacy rectangle fields remain required when the second argument is supplied. + stage.renderTo(target, { x: 10 }); + // @ts-expect-error Legacy rectangle fields do not belong to drawing options. + stage.renderTo(target, undefined, { x: 10 }); + const virtual: Partial = { interactiveLayer: true, interactiveLayerMode: 'virtual' }; + // @ts-expect-error interactiveLayer remains boolean; the layer mode is a separate option. + const invalid: Partial = { interactiveLayer: 'group' }; + // @ts-expect-error Interactive layers support physical or virtual backends, not incremental dynamic layers. + const dynamic: Partial = { interactiveLayerMode: 'dynamic' }; + return { enabled, virtual, invalid, dynamic }; +} diff --git a/packages/vrender-core/__tests__/unit/common/host-input.test.ts b/packages/vrender-core/__tests__/unit/common/host-input.test.ts new file mode 100644 index 000000000..fa09eadc5 --- /dev/null +++ b/packages/vrender-core/__tests__/unit/common/host-input.test.ts @@ -0,0 +1,126 @@ +/** @jest-environment jsdom */ +import { EventEmitter } from '@visactor/vutils'; +import { EventSystem } from '../../../src/event/event-system'; +import type { RenderConfig } from '../../../src/interface/event'; + +function setup() { + const canvas = document.createElement('canvas'); + const root = Object.assign(new EventEmitter(), { + parent: null, + stage: { renderCount: 0 }, + attribute: {}, + getCursor: () => '', + pick: () => ({ graphic: root }) + }); + const system = new EventSystem({ + targetElement: canvas, + resolution: 1, + rootNode: root, + global: { supportsMouseEvents: true, supportsPointerEvents: false, supportsTouchEvents: false }, + useNativeEvents: false + } as unknown as RenderConfig); + const send = (type: string, inside = true) => + system.handleNativeEvent(new MouseEvent(type, { clientX: 60, clientY: 50, button: 0 }), { + canvasPoint: { x: 20, y: 20 }, + inViewport: inside + }); + return { system, root, send }; +} +test('cancel in down listener prevents later click', () => { + const { system, root, send } = setup(); + const click = jest.fn(); + root.on('pointerdown', () => system.cancelPointer(1)); + root.on('click', click); + send('mousedown'); + send('mouseup'); + expect(click).not.toHaveBeenCalled(); + system.release(); +}); +test('outside up is published once to window only', () => { + const { system, send } = setup(); + const win = jest.fn(); + const canvas = jest.fn(); + system.input.window.on('pointerup', win); + system.input.canvas.on('pointerup', canvas); + send('mousedown'); + send('mouseup', false); + expect(win).toHaveBeenCalledTimes(1); + expect(canvas).not.toHaveBeenCalled(); + system.release(); +}); +test('input reentered during cancel starts after old terminal notifications', () => { + const { system, root, send } = setup(); + const order: string[] = []; + root.on('pointerdown', () => order.push('down')); + root.on('pointercancel', () => { + order.push('cancel'); + send('mousedown'); + }); + system.input.window.on('pointercancel', () => order.push('window-cancel')); + send('mousedown'); + system.cancelPointer(1); + expect(order).toEqual(['down', 'cancel', 'window-cancel', 'down']); + root.removeAllListeners(); + system.release(); +}); + +test.each(['target', 'window', 'canvas'])('release in %s down callback stops further dispatch', scope => { + const { system, root, send } = setup(); + const later = jest.fn(); + if (scope === 'target') { + root.on('pointerdown', () => system.release()); + } else { + system.input[scope].on('pointerdown', () => system.release()); + } + system.input.canvas.on('mousedown', later); + expect(() => send('mousedown')).not.toThrow(); + expect(later).not.toHaveBeenCalled(); + expect(() => send('mouseup')).not.toThrow(); +}); +test('window up cancellation suppresses click and canvas up', () => { + const { system, root, send } = setup(); + const click = jest.fn(); + const up = jest.fn(); + root.on('click', click); + system.input.canvas.on('pointerup', up); + system.input.window.on('pointerup', () => system.cancelPointer(1)); + send('mousedown'); + send('mouseup'); + expect(click).not.toHaveBeenCalled(); + expect(up).not.toHaveBeenCalled(); + system.release(); +}); +test('ignoring one move does not implicitly cancel an accepted press', () => { + const { system, root, send } = setup(); + const click = jest.fn(); + root.on('click', click); + send('mousedown'); // The host does not deliver an unrelated move. + send('mousemove'); + send('mouseup'); + expect(click).toHaveBeenCalledTimes(1); + system.release(); +}); + +test('new input enqueued while draining cancellation stays behind already queued input', () => { + const { system, root, send } = setup(); + const order: string[] = []; + let restarting = false; + root.on('pointerdown', () => { + if (restarting) { + order.push('down'); + send('mousemove'); + } + }); + root.on('pointerup', () => order.push('up')); + root.on('pointermove', () => order.push('move')); + root.on('pointercancel', () => { + restarting = true; + send('mousedown'); + send('mouseup'); + }); + send('mousedown'); + system.cancelPointer(1); + expect(order).toEqual(['down', 'up', 'move']); + root.removeAllListeners(); + system.release(); +}); diff --git a/packages/vrender-core/__tests__/unit/common/native-events.test.ts b/packages/vrender-core/__tests__/unit/common/native-events.test.ts new file mode 100644 index 000000000..8681edba0 --- /dev/null +++ b/packages/vrender-core/__tests__/unit/common/native-events.test.ts @@ -0,0 +1,147 @@ +/** @jest-environment jsdom */ +import { EventEmitter } from '@visactor/vutils'; +import { EventSystem } from '../../../src/event/event-system'; +import type { RenderConfig } from '../../../src/interface/event'; + +// Scene boundary only; normalization, mapping, propagation and click tracking are real. +function setup() { + const canvas = document.createElement('canvas'); + document.body.appendChild(canvas); + const root = Object.assign(new EventEmitter(), { + parent: null, + stage: { renderCount: 0 }, + attribute: {}, + getCursor: () => 'pointer', + pick: () => ({ graphic: root }) + }); + const system = new EventSystem({ + targetElement: canvas, + resolution: 1, + rootNode: root, + global: { supportsMouseEvents: true, supportsPointerEvents: false, supportsTouchEvents: false }, + useNativeEvents: false + } as unknown as RenderConfig); + const events: string[] = []; + const errors: unknown[] = []; + let allowed = true; + let authorized: Event; + const arbitrate = (event: Event) => { + if (allowed) { + authorized = event; + } + }; + document.addEventListener('mousedown', arbitrate); + document.addEventListener('mousemove', arbitrate); + document.addEventListener('mouseup', arbitrate); + ['pointerdown', 'pointerup', 'pointercancel', 'pointerout', 'click'].forEach(type => + root.on(type, () => events.push(type)) + ); + const receive = (event: MouseEvent) => { + if (event !== authorized || event.target !== canvas) { + return; + } + system.handleNativeEvent(event, { + canvasPoint: { x: (event.clientX - 20) / 2, y: (event.clientY - 10) / 2 }, + inViewport: true + }); + }; + const blur = () => system.cancelAllPointers(); + const types = ['mousedown', 'mousemove', 'mouseup']; + types.forEach(type => document.addEventListener(type, receive)); + window.addEventListener('blur', blur); + const unbind = () => { + types.forEach(type => document.removeEventListener(type, receive)); + window.removeEventListener('blur', blur); + }; + return { + system, + unbind, + canvas, + root, + events, + errors, + allow(value: boolean) { + allowed = value; + }, + send(type: string, target: HTMLElement = canvas) { + target.dispatchEvent(new MouseEvent(type, { bubbles: true, clientX: 60, clientY: 50, button: 0 })); + }, + release() { + unbind(); + system.release(); + ['mousedown', 'mousemove', 'mouseup'].forEach(type => document.removeEventListener(type, arbitrate)); + canvas.remove(); + expect(errors).toEqual([]); + } + }; +} + +describe('native input ownership', () => { + test('host arbitration precedes normalization and rejected down cannot click on allowed up', () => { + const s = setup(); + const point: number[] = []; + s.root.on('pointerup', event => point.push(event.canvasX, event.canvasY)); + s.allow(false); + s.send('mousedown'); + s.allow(true); + s.send('mouseup'); + expect(s.events).toEqual(['pointerup']); + expect(point).toEqual([20, 20]); + s.release(); + }); + + test('takeover cancels the press and hover without a later click', () => { + const s = setup(); + s.send('mousemove'); + s.send('mousedown'); + s.allow(false); + s.system.cancelAllPointers(); + s.send('mousemove'); + s.allow(true); + s.send('mouseup'); + expect(s.events).toContain('pointercancel'); + expect(s.events).toContain('pointerout'); + expect(s.events).not.toContain('click'); + s.release(); + }); + + test('explicit reset is synchronous and idempotent', () => { + const s = setup(); + s.send('mousemove'); + s.send('mousedown'); + s.system.cancelAllPointers(); + const afterReset = s.events.slice(); + expect(afterReset).toContain('pointercancel'); + s.system.cancelAllPointers(); + expect(s.events).toEqual(afterReset); + s.send('mouseup'); + expect(s.events).not.toContain('click'); + s.release(); + }); + + test('authorized input over a foreign DOM element still cannot hit the chart', () => { + const s = setup(); + const button = document.createElement('button'); + document.body.appendChild(button); + s.send('mousedown', button); + s.send('mouseup', button); + expect(s.events).toEqual([]); + button.remove(); + s.release(); + }); + + test('blur clears the gesture and unbinding removes native listeners', () => { + const s = setup(); + s.send('mousedown'); + window.dispatchEvent(new Event('blur')); + s.send('mouseup'); + expect(s.events).toContain('pointercancel'); + expect(s.events).not.toContain('click'); + s.unbind(); + const before = s.events.slice(); + s.send('mousedown'); + s.send('mouseup'); + expect(s.events).toEqual(before); + s.release(); + }); +}); diff --git a/packages/vrender-core/__tests__/unit/render/interactive-graphic-bounds.test.ts b/packages/vrender-core/__tests__/unit/render/interactive-graphic-bounds.test.ts index 6fb9c1b1e..04f943540 100644 --- a/packages/vrender-core/__tests__/unit/render/interactive-graphic-bounds.test.ts +++ b/packages/vrender-core/__tests__/unit/render/interactive-graphic-bounds.test.ts @@ -32,7 +32,7 @@ function createDrawContextStub() { drawContext: { stage: { tryInitInteractiveLayer: (): void => undefined, - getLayer: (name: string): any => (name === '_builtin_interactive' ? interactiveLayer : undefined) + getLayer: (): any => interactiveLayer } } }; diff --git a/packages/vrender-core/__tests__/unit/smoke/stage-interactive-layer.test.ts b/packages/vrender-core/__tests__/unit/smoke/stage-interactive-layer.test.ts new file mode 100644 index 000000000..b58736a30 --- /dev/null +++ b/packages/vrender-core/__tests__/unit/smoke/stage-interactive-layer.test.ts @@ -0,0 +1,51 @@ +/** @jest-environment node */ +import { createNodeSmokeStage } from './node-smoke-stage'; +import { registerGroupGraphic } from '../../../src/register/register-group'; +import { registerShadowRootGraphic } from '../../../src/register/register-shadowRoot'; +import { createRect } from '../../../src/graphic/rect'; +import { EmptyLayerHandlerContribution } from '../../../src/core/contributions/layerHandler/empty-contribution'; +import type { IStageParams } from '../../../src/interface'; + +describe('interactive layer mode', () => { + beforeAll(() => { + registerGroupGraphic(); + registerShadowRootGraphic(); + }); + test.each([ + ['disabled', { interactiveLayer: false }, false], + ['virtual', { interactiveLayerMode: 'virtual' }, true], + ['explicit enabled', { interactiveLayer: true, interactiveLayerMode: 'virtual' }, true], + ['disabled with mode', { interactiveLayer: false, interactiveLayerMode: 'virtual' }, false] + ] as [string, Partial, boolean][])('%s', (_, options, enabled) => { + const stage = createNodeSmokeStage({ + width: 100, + height: 100, + autoRender: false, + autoRefresh: false, + event: { useNativeEvents: false }, + ...options + }); + try { + stage.tryInitInteractiveLayer(); + const layer = stage.getLayer('_builtin_interactive'); + expect(Boolean(layer)).toBe(enabled); + expect(stage.childrenCount).toBe(enabled ? 2 : 1); + if (layer) { + expect(layer.layerMode).toBe('virtual'); + expect(layer.parent).toBe(stage); + const handler = layer.getNativeHandler(); + expect(handler).toBeInstanceOf(EmptyLayerHandlerContribution); + if (handler instanceof EmptyLayerHandlerContribution) { + expect(handler.canvas).toBeNull(); + } + const rect = createRect({ x: 10, y: 10, width: 20, height: 20, fill: 'red', globalZIndex: 1 }); + stage.defaultLayer.add(rect); + stage.render(); + expect(rect.interactiveGraphic?.baseGraphic).toBe(rect); + expect(rect.interactiveGraphic?.parent).toBe(layer.getElementById('_interactive_group')?.shadowRoot); + } + } finally { + stage.release(); + } + }); +}); diff --git a/packages/vrender-core/src/core/contributions/layerHandler/modules.ts b/packages/vrender-core/src/core/contributions/layerHandler/modules.ts index c39fe2fe6..4ec256ec5 100644 --- a/packages/vrender-core/src/core/contributions/layerHandler/modules.ts +++ b/packages/vrender-core/src/core/contributions/layerHandler/modules.ts @@ -1,19 +1,19 @@ import { // DynamicLayerHandlerContribution, - StaticLayerHandlerContribution - // VirtualLayerHandlerContribution + StaticLayerHandlerContribution, + VirtualLayerHandlerContribution } from '../../constants'; import { CanvasLayerHandlerContribution } from './canvas2d-contribution'; -// import { EmptyLayerHandlerContribution } from './empty-contribution'; +import { EmptyLayerHandlerContribution } from './empty-contribution'; // import { OffscreenLayerHandlerContribution } from './offscreen2d-contribution'; export function bindLayerHandlerModules({ bind }: { bind: any }) { bind(CanvasLayerHandlerContribution).toSelf(); // bind(OffscreenLayerHandlerContribution).toSelf(); - // bind(EmptyLayerHandlerContribution).toSelf(); + bind(EmptyLayerHandlerContribution).toSelf(); bind(StaticLayerHandlerContribution).toService(CanvasLayerHandlerContribution); // bind(DynamicLayerHandlerContribution).toService(OffscreenLayerHandlerContribution); - // bind(VirtualLayerHandlerContribution).toService(EmptyLayerHandlerContribution); + bind(VirtualLayerHandlerContribution).toService(EmptyLayerHandlerContribution); // try { // if (typeof OffscreenCanvas === 'function') { // bind(LayerHandlerContribution).toService(OffscreenLayerHandlerContribution); diff --git a/packages/vrender-core/src/core/stage.ts b/packages/vrender-core/src/core/stage.ts index 0808dbf6a..055920455 100644 --- a/packages/vrender-core/src/core/stage.ts +++ b/packages/vrender-core/src/core/stage.ts @@ -9,6 +9,7 @@ import { } from '@visactor/vutils'; import type { IGraphic, + IGroup, IExportType, IStage, IStageParams, @@ -33,11 +34,12 @@ import type { PickResult, IPlugin, IGraphicService, - IRenderServiceDrawParams + IRenderServiceDrawParams, + IRenderToOptions } from '../interface'; import { DefaultWindow } from './window'; import type { Layer } from './layer'; -import { EventSystem } from '../event'; +import { EventSystem, FederatedMouseEvent } from '../event'; import { Group } from '../graphic/group'; import { Theme } from '../graphic/theme'; import { DefaultGlobalPickerService } from '../picker/global-picker-service'; @@ -268,7 +270,7 @@ export class Stage extends Group implements IStage { deps.pickerServiceFactory ?? (deps.pickerService ? () => deps.pickerService as IPickerService - : application.pickerServiceFactory ?? (() => new DefaultGlobalPickerService())); + : (application.pickerServiceFactory ?? (() => new DefaultGlobalPickerService()))); this.window = deps.window ?? this.windowFactory(); this.renderService = deps.renderService ?? @@ -795,6 +797,9 @@ export class Stage extends Group implements IStage { canvasId }); this.appendChild(layer); + if (this.interactiveLayer && layer !== this.interactiveLayer) { + this.appendChild(this.interactiveLayer); + } return layer; // const layer = new Layer(this, this.global, this.window, { // main: false, @@ -810,6 +815,9 @@ export class Stage extends Group implements IStage { children.forEach(c => { this.appendChild(c); }); + if (this.interactiveLayer) { + this.appendChild(this.interactiveLayer); + } } removeLayer(ILayerId: number): ILayer | false { return this.removeChild(this.findChildByUid(ILayerId) as IGraphic) as ILayer; @@ -818,10 +826,9 @@ export class Stage extends Group implements IStage { if (this.releaseStatus === 'released') { return; } - // TODO:顺序可能会存在问题 // 支持交互层,且没有创建过,那就创建 if (this.supportInteractiveLayer && !this.interactiveLayer) { - this.interactiveLayer = this.createLayer(); + this.interactiveLayer = this.createLayer(undefined, this.params.interactiveLayerMode); this.interactiveLayer.name = '_builtin_interactive'; this.interactiveLayer.attribute.pickable = false; this.nextFrameRenderLayerSet.add(this.interactiveLayer as any); // to be fixed @@ -831,6 +838,14 @@ export class Stage extends Group implements IStage { // }); } + private prepareRenderLayers(): void { + // The virtual handler needs a main handler before traversal; lazy creation during draw is too late. + if (this.params.interactiveLayerMode === 'virtual') { + this.tryInitInteractiveLayer(); + } + this.layerService.prepareStageLayer(this); + } + clearViewBox(color?: string) { this.window.clearViewBox(color); } @@ -839,14 +854,18 @@ export class Stage extends Group implements IStage { if (this.releaseStatus === 'released') { return; } + if (this.params.requestRender) { + this.params.requestRender(); + return; + } this.startAnimate(); const state = this.state; this.state = 'rendering'; - this.layerService.prepareStageLayer(this); if (!this._skipRender) { this.lastRenderparams = params; this.hooks.beforeRender.call(this); if (!this._skipRender) { + this.prepareRenderLayers(); this.renderLayerList(this.children as ILayer[]); this.combineLayersToWindow(); this.nextFrameRenderLayerSet.clear(); @@ -887,6 +906,15 @@ export class Stage extends Group implements IStage { } renderNextFrame(layers?: ILayer[], force?: boolean): void { + if (this.releaseStatus === 'released') { + return; + } + if (this.params.requestRender) { + if (this.state !== 'rendering') { + this.params.requestRender(); + } + return; + } // render状态中调用的不会触发nextFrame,避免loop // if (this.state === 'rendering' && !force) { // console.log('abc'); @@ -925,10 +953,10 @@ export class Stage extends Group implements IStage { this.startAnimate(); const state = this.state; this.state = 'rendering'; - this.layerService.prepareStageLayer(this); if (this.nextFrameRenderLayerSet.size && !this._skipRender) { this.hooks.beforeRender.call(this); if (!this._skipRender) { + this.prepareRenderLayers(); this.renderLayerList(Array.from(this.nextFrameRenderLayerSet.values()), this.lastRenderparams || {}); this.combineLayersToWindow(); this.nextFrameRenderLayerSet.clear(); @@ -1146,21 +1174,37 @@ export class Stage extends Group implements IStage { return layer[0] as ILayer; } - renderTo(window: IWindow) { + renderTo( + window: IWindow, + _params?: { x: number; y: number; width: number; height: number }, + options?: IRenderToOptions + ) { if (this.releaseStatus === 'released') { return; } - this.forEachChildren((layer, i) => { - layer.drawTo(window, { - // ...params, - renderService: this.renderService, - viewBox: window.getViewBox(), - transMatrix: window.getViewBoxTransform(), - background: layer === this.defaultLayer ? this.background : undefined, - clear: i === 0, // 第一个layer需要clear - updateBounds: !!(this.dirtyBounds && !this.dirtyBounds.empty()) + const state = this.state; + this.state = 'rendering'; + try { + if (this.params.requestRender) { + this.hooks.beforeRender.call(this); + } + this.prepareRenderLayers(); + this.forEachChildren((layer, i) => { + layer.drawTo(window, { + renderService: this.renderService, + viewBox: options?.viewBox ?? window.getViewBox(), + transMatrix: options?.transMatrix ?? window.getViewBoxTransform(), + background: layer === this.defaultLayer ? this.background : undefined, + clear: i === 0 && options?.clear !== false, + updateBounds: !!(this.dirtyBounds && !this.dirtyBounds.empty()) + }); }); - }); + if (this.params.requestRender) { + this.hooks.afterRender.call(this); + } + } finally { + this.state = state; + } } /** @@ -1226,7 +1270,10 @@ export class Stage extends Group implements IStage { return this._cursor; } - eventPointTransform(e: PointerEvent | WheelEvent | TouchEvent): { x: number; y: number } { + eventPointTransform(e: PointerEvent | WheelEvent | TouchEvent | FederatedMouseEvent): { x: number; y: number } { + if (e instanceof FederatedMouseEvent) { + return { x: e.viewX, y: e.viewY }; + } const point = this.global.mapToCanvasPoint(e, this.window); return this.stage.window.pointTransform(point.x, point.y); diff --git a/packages/vrender-core/src/event/event-manager.ts b/packages/vrender-core/src/event/event-manager.ts index 18214de14..6ca52ec40 100644 --- a/packages/vrender-core/src/event/event-manager.ts +++ b/packages/vrender-core/src/event/event-manager.ts @@ -1,3 +1,4 @@ +import { InputSource } from './input-source'; import type { Dict } from '@visactor/vutils'; import { EventEmitter, Logger, get } from '@visactor/vutils'; import { FederatedMouseEvent, FederatedPointerEvent, FederatedWheelEvent } from './federated-event'; @@ -35,6 +36,17 @@ import type { Cursor, IGraphic } from '../interface'; const PROPAGATION_LIMIT = 2048; type TrackingData = { + generation: number; + inside: boolean; + previousInside: boolean; + ending?: IEventTarget[]; + pointerType: string; + button: number; + canvasX: number; + canvasY: number; + viewX: number; + viewY: number; + pressTargetsByButton: { [id: number]: IEventTarget[]; }; @@ -65,6 +77,16 @@ function isMouseLike(pointerType: string) { } const DEFAULT_CLICK_INTERVAL = 200; +const TOUCH_INPUT_TYPES: Record = { + pointerdown: 'touchstart', + pointermove: 'touchmove', + pointerup: 'touchend' +}; +const MOUSE_INPUT_TYPES: Record = { + pointerdown: 'mousedown', + pointermove: 'mousemove', + pointerup: 'mouseup' +}; export class EventManager { rootTarget: IEventTarget; @@ -108,9 +130,184 @@ export class EventManager { this.addEventMapping('pointerover', this.onPointerOver); this.addEventMapping('pointerup', this.onPointerUp); this.addEventMapping('pointerupoutside', this.onPointerUpOutside); + this.addEventMapping('pointercancel', this.onPointerCancel); this.addEventMapping('wheel', this.onWheel); } + private readonly canvasInput = new InputSource(); + private readonly windowInput = new InputSource(); + readonly input = { canvas: this.canvasInput.source, window: this.windowInput.source }; + private currentTracking?: TrackingData; + private currentGeneration = 0; + private terminalDepth = 0; + private dispatchingEvent?: FederatedEvent; + + private inputValid = (): boolean => + !!this.rootTarget && + (this.terminalDepth > 0 || !this.currentTracking || this.currentTracking.generation === this.currentGeneration); + + hasPointer(id: number): boolean { + const data = this.mappingState.trackingData[id] as TrackingData; + if (!data) { + return false; + } + if (data.inside || data.ending) { + return true; + } + for (const button in data.pressTargetsByButton) { + if (data.pressTargetsByButton[button]) { + return true; + } + } + return false; + } + + cancelAllPointers(): void { + for (const id in this.mappingState.trackingData) { + this.cancelPointer(Number(id)); + } + } + + cancelPointer(id: number): void { + if (!this.rootTarget || !this.hasPointer(id)) { + return; + } + const data = this.trackingData(id); + let press = data.ending; + for (const button in data.pressTargetsByButton) { + press = data.pressTargetsByButton[button]; + break; + } + const over = data.overTargets; + const inside = data.inside; + // Commit the terminal state before any callback, including capture listeners. + data.generation++; + data.pressTargetsByButton = {}; + data.clicksByButton = {}; + data.ending = undefined; + data.inside = false; + data.overTargets = []; + if (this.dispatchingEvent instanceof FederatedPointerEvent && this.dispatchingEvent.pointerId === id) { + this.dispatchingEvent.stopImmediatePropagation(); + } + const event = this.allocateEvent(FederatedPointerEvent); + event.type = 'pointercancel'; + event.pointerId = id; + event.pointerType = data.pointerType; + event.button = data.button; + event.nativeEvent = null; + event.canvas.x = data.canvasX; + event.canvas.y = data.canvasY; + event.viewport.x = data.viewX; + event.viewport.y = data.viewY; + event.target = this.findMountedTarget(press) ?? this.findMountedTarget(over); + this.terminalDepth++; + try { + this.dispatchEvent(event); + if (event.pointerType === 'touch') { + this.dispatchEvent(event, 'touchcancel'); + } + this.windowInput.emit('pointercancel', event, this.inputValid); + if (event.pointerType === 'touch') { + this.windowInput.emit('touchcancel', event, this.inputValid); + } + if (inside) { + this.canvasInput.emit('pointercancel', event, this.inputValid); + if (event.pointerType === 'touch') { + this.canvasInput.emit('touchcancel', event, this.inputValid); + } + this.emitBoundary(event, false); + } + if (over?.length && this.rootTarget) { + event.target = this.findMountedTarget(over); + event.path = []; + this.dispatchEvent(event, 'pointerout'); + if (isMouseLike(event.pointerType)) { + this.dispatchEvent(event, 'mouseout'); + } + event.eventPhase = event.AT_TARGET; + while (event.target && this.rootTarget) { + event.currentTarget = event.target; + this.notifyTarget(event, 'pointerleave'); + if (isMouseLike(event.pointerType)) { + this.notifyTarget(event, 'mouseleave'); + } + event.target = event.target.parent as IEventTarget; + } + } + } finally { + this.terminalDepth--; + this.freeEvent(event); + this.cursorTarget = null; + this.cursor = ''; + } + } + + private emitBoundary(event: FederatedPointerEvent, inside: boolean): void { + this.canvasInput.emit(inside ? 'pointerover' : 'pointerout', event, this.inputValid); + this.canvasInput.emit(inside ? 'pointerenter' : 'pointerleave', event, this.inputValid); + if (isMouseLike(event.pointerType)) { + this.canvasInput.emit(inside ? 'mouseover' : 'mouseout', event, this.inputValid); + this.canvasInput.emit(inside ? 'mouseenter' : 'mouseleave', event, this.inputValid); + } + } + + private emitInput(event: FederatedMouseEvent, type = event.type): void { + if (!this.inputValid()) { + return; + } + this.windowInput.emit(type, event, this.inputValid); + if (!this.inputValid()) { + return; + } + const data = event instanceof FederatedPointerEvent ? this.trackingData(event.pointerId) : undefined; + if (data && data.previousInside !== data.inside) { + data.previousInside = data.inside; + this.emitBoundary(event as FederatedPointerEvent, data.inside); + } + if (!data || data.inside) { + this.canvasInput.emit(type, event, this.inputValid); + } + } + + private emitPointerInput(event: FederatedPointerEvent, type = event.type): void { + if (!this.inputValid()) { + return; + } + // Native over/out represent logical transitions only, not sibling mark transitions. + if (type === 'pointerover' || type === 'pointerout' || type === 'pointerleave') { + const data = this.trackingData(event.pointerId); + if (data.previousInside !== data.inside) { + data.previousInside = data.inside; + this.emitBoundary(event, data.inside); + } + return; + } + this.emitInput(event, type); + if (event.pointerType === 'touch') { + const alias = TOUCH_INPUT_TYPES[type]; + if (alias) { + this.emitInput(event, alias); + } + } else if (isMouseLike(event.pointerType)) { + const alias = + event.button === 2 && type === 'pointerdown' + ? 'rightdown' + : event.button === 2 && type === 'pointerup' + ? 'rightup' + : MOUSE_INPUT_TYPES[type]; + if (alias) { + this.emitInput(event, alias); + } + } + } + + protected onPointerCancel = (from: FederatedEvent): void => { + if (from instanceof FederatedPointerEvent) { + this.cancelPointer(from.pointerId); + } + }; + addEventMapping(type: string, fn: (e: FederatedEvent, target: IEventTarget) => void): void { if (!this.mappingTable[type]) { this.mappingTable[type] = []; @@ -124,46 +321,92 @@ export class EventManager { } dispatchEvent(e: FederatedEvent, type?: string): void { + if (!this.inputValid()) { + return; + } + const previous = this.dispatchingEvent; + this.dispatchingEvent = e; e.propagationStopped = false; e.propagationImmediatelyStopped = false; - this.propagate(e, type); - this.dispatch.emit(type || e.type, e); + try { + this.propagate(e, type); + if (this.inputValid()) { + this.dispatch.emit(type || e.type, e); + } + } finally { + this.dispatchingEvent = previous; + } } - mapEvent(e: FederatedEvent): void { + mapEvent(e: FederatedEvent, inViewport = true): void { if (!this.rootTarget) { return; } - const mappers = this.mappingTable[e.type]; - - let target; - const cacheKey = `${e.canvasX}-${e.canvasY}`; - if ( - this._prePointTargetCache?.[cacheKey] && - (this._prePointTargetCache?.[cacheKey] as unknown as IGraphic)?.stage && - (this._prePointTargetCache?.[cacheKey] as unknown as IGraphic)?.stage.renderCount === - (this._prePointTargetCache?.stageRenderCount as number) - ) { - target = this._prePointTargetCache[cacheKey]; - } else { - target = this.pickTarget(e.viewX, e.viewY, e); - // 缓存上一个坐标点的拾取结果,减少拾取的次数,如 pointermove pointerdown 和 pointerup 在同一个点触发 - // 如果存在params,那么就不缓存 - if (!(e as any).pickParams) { - this._prePointTargetCache = { - [cacheKey]: target, - stageRenderCount: target?.stage.renderCount ?? -1 - }; - } + const previous = this.currentTracking; + const generation = this.currentGeneration; + const tracking = e instanceof FederatedPointerEvent ? this.trackingData(e.pointerId) : undefined; + this.currentTracking = tracking; + this.currentGeneration = tracking?.generation ?? 0; + if (tracking) { + tracking.previousInside = tracking.inside; + tracking.inside = inViewport; + tracking.pointerType = (e as FederatedPointerEvent).pointerType; + tracking.button = (e as FederatedPointerEvent).button; + tracking.canvasX = e.canvasX; + tracking.canvasY = e.canvasY; + tracking.viewX = e.viewX; + tracking.viewY = e.viewY; } + const type = e.type === 'pointerup' && !inViewport ? 'pointerupoutside' : e.type; + const mappers = this.mappingTable[type]; + try { + let target; + const cacheKey = `${e.canvasX}-${e.canvasY}`; + if (!inViewport) { + target = null; + } else if ( + this._prePointTargetCache?.[cacheKey] && + (this._prePointTargetCache?.[cacheKey] as unknown as IGraphic)?.stage && + (this._prePointTargetCache?.[cacheKey] as unknown as IGraphic)?.stage.renderCount === + (this._prePointTargetCache?.stageRenderCount as number) + ) { + target = this._prePointTargetCache[cacheKey]; + } else { + target = this.pickTarget(e.viewX, e.viewY, e); + // 缓存上一个坐标点的拾取结果,减少拾取的次数,如 pointermove pointerdown 和 pointerup 在同一个点触发 + // 如果存在params,那么就不缓存 + if (!(e as any).pickParams) { + this._prePointTargetCache = { + [cacheKey]: target, + stageRenderCount: target?.stage.renderCount ?? -1 + }; + } + } - if (mappers) { - for (let i = 0, j = mappers.length; i < j; i++) { - mappers[i].fn(e, target); + if (mappers) { + for (let i = 0, j = mappers.length; i < j && this.inputValid(); i++) { + mappers[i].fn(e, target); + } + } else { + Logger.getInstance().warn(`[EventManager]: Event mapping not defined for ${e.type}`); } - } else { - Logger.getInstance().warn(`[EventManager]: Event mapping not defined for ${e.type}`); + if ( + e instanceof FederatedPointerEvent && + type !== 'pointerup' && + type !== 'pointerupoutside' && + type !== 'pointercancel' + ) { + this.emitPointerInput(e); + } else if (e instanceof FederatedWheelEvent) { + this.emitInput(e); + } + } finally { + if (tracking) { + tracking.ending = undefined; + } + this.currentTracking = previous; + this.currentGeneration = generation; } } @@ -226,6 +469,10 @@ export class EventManager { } protected notifyTarget(e: FederatedEvent, type?: string): void { + if (!this.inputValid()) { + e.stopImmediatePropagation(); + return; + } if (this.pauseNotify) { return; } @@ -234,7 +481,7 @@ export class EventManager { this.notifyListeners(e, key); - if (e.eventPhase === e.AT_TARGET) { + if (e.eventPhase === e.AT_TARGET && this.inputValid() && !e.propagationImmediatelyStopped) { this.notifyListeners(e, type); } } @@ -248,6 +495,8 @@ export class EventManager { const e = this.createPointerEvent(from, from.type, target); + const trackingData = this.trackingData(from.pointerId); + trackingData.pressTargetsByButton[from.button] = e.composedPath(); this.dispatchEvent(e, 'pointerdown'); if (e.pointerType === 'touch') { @@ -258,10 +507,6 @@ export class EventManager { this.dispatchEvent(e, isRightButton ? 'rightdown' : 'mousedown'); } - const trackingData = this.trackingData(from.pointerId); - - trackingData.pressTargetsByButton[from.button] = e.composedPath(); - this.freeEvent(e); }; @@ -318,7 +563,7 @@ export class EventManager { let overTargetAncestor = outTarget?.parent; - while (overTargetAncestor && overTargetAncestor !== this.rootTarget.parent) { + while (this.inputValid() && overTargetAncestor && overTargetAncestor !== this.rootTarget.parent) { if (overTargetAncestor === e.target) { break; } @@ -326,7 +571,8 @@ export class EventManager { overTargetAncestor = overTargetAncestor.parent; } - const didPointerEnter = !overTargetAncestor || overTargetAncestor === this.rootTarget.parent; + const didPointerEnter = + this.inputValid() && (!overTargetAncestor || overTargetAncestor === this.rootTarget.parent); if (didPointerEnter) { const enterEvent = this.clonePointerEvent(e, 'pointerenter'); @@ -342,7 +588,12 @@ export class EventManager { ancestor = ancestor.parent; } - while (currentTarget && currentTarget !== outTarget && currentTarget !== this.rootTarget.parent) { + while ( + this.inputValid() && + currentTarget && + currentTarget !== outTarget && + currentTarget !== this.rootTarget.parent + ) { // 检查 currentTarget 是否是 outTarget 的祖先 if (!outTargetAncestors.has(currentTarget)) { enterEvent.currentTarget = currentTarget; @@ -370,13 +621,15 @@ export class EventManager { this[propagationMethod](e, 'touchmove'); } - if (isMouse) { + if (isMouse && this.inputValid()) { this[propagationMethod](e, 'mousemove'); this.cursorTarget = e.target; this.cursor = (e.target?.attribute?.cursor as Cursor) || this.rootTarget.getCursor(); } - trackingData.overTargets = e.composedPath(); + if (this.inputValid()) { + trackingData.overTargets = e.composedPath(); + } this.freeEvent(e); }; @@ -396,7 +649,7 @@ export class EventManager { if (isMouse) { this.dispatchEvent(e, 'mouseover'); } - if (e.pointerType === 'mouse') { + if (e.pointerType === 'mouse' && this.inputValid()) { this.cursorTarget = e.target; this.cursor = (e.target?.attribute?.cursor as Cursor) || this.rootTarget.getCursor(); } @@ -405,7 +658,7 @@ export class EventManager { enterEvent.eventPhase = enterEvent.AT_TARGET; - while (enterEvent.target && enterEvent.target !== this.rootTarget.parent) { + while (this.inputValid() && enterEvent.target && enterEvent.target !== this.rootTarget.parent) { enterEvent.currentTarget = enterEvent.target; this.notifyTarget(enterEvent); @@ -416,7 +669,9 @@ export class EventManager { enterEvent.target = enterEvent.target.parent as IEventTarget; } - trackingData.overTargets = e.composedPath(); + if (this.inputValid()) { + trackingData.overTargets = e.composedPath(); + } this.freeEvent(e); this.freeEvent(enterEvent); @@ -446,7 +701,7 @@ export class EventManager { leaveEvent.eventPhase = leaveEvent.AT_TARGET; - while (leaveEvent.target && leaveEvent.target !== this.rootTarget.parent) { + while (this.inputValid() && leaveEvent.target && leaveEvent.target !== this.rootTarget.parent) { leaveEvent.currentTarget = leaveEvent.target; this.notifyTarget(leaveEvent); @@ -477,6 +732,9 @@ export class EventManager { const now = clock.now(); const e = this.createPointerEvent(from, from.type, target); + const trackingData = this.trackingData(from.pointerId); + trackingData.ending = trackingData.pressTargetsByButton[from.button]; + delete trackingData.pressTargetsByButton[from.button]; this.dispatchEvent(e, 'pointerup'); if (e.pointerType === 'touch') { @@ -487,8 +745,7 @@ export class EventManager { this.dispatchEvent(e, isRightButton ? 'rightup' : 'mouseup'); } - const trackingData = this.trackingData(from.pointerId); - const pressTarget = this.findMountedTarget(trackingData.pressTargetsByButton[from.button]); + const pressTarget = this.findMountedTarget(trackingData.ending); let clickTarget = pressTarget; @@ -516,7 +773,8 @@ export class EventManager { clickTarget = currentTarget; } - if (clickTarget) { + this.emitPointerInput(e, 'pointerup'); + if (clickTarget && this.inputValid()) { const clickEvent = this.clonePointerEvent(e, 'click'); clickEvent.target = clickTarget; @@ -548,20 +806,25 @@ export class EventManager { if (isMouseLike(clickEvent.pointerType)) { this.dispatchEvent(clickEvent, 'click'); + this.emitInput(clickEvent, 'click'); if (clickHistory.clickCount === 2) { // 双击 this.dispatchEvent(clickEvent, 'dblclick'); + this.emitInput(clickEvent, 'dblclick'); } } else if (clickEvent.pointerType === 'touch' && this._config.supportsTouchEvents) { this.dispatchEvent(clickEvent, 'tap'); + this.emitInput(clickEvent, 'tap'); if (clickHistory.clickCount === 2) { // 双击 this.dispatchEvent(clickEvent, 'dbltap'); + this.emitInput(clickEvent, 'dbltap'); } } this.dispatchEvent(clickEvent, 'pointertap'); + this.emitInput(clickEvent, 'pointertap'); this.freeEvent(clickEvent); } @@ -577,7 +840,9 @@ export class EventManager { } const trackingData = this.trackingData(from.pointerId); - const pressTarget = this.findMountedTarget(trackingData.pressTargetsByButton[from.button]); + trackingData.ending = trackingData.pressTargetsByButton[from.button]; + delete trackingData.pressTargetsByButton[from.button]; + const pressTarget = this.findMountedTarget(trackingData.ending); const e = this.createPointerEvent(from, from.type, target); if (pressTarget) { @@ -600,6 +865,7 @@ export class EventManager { delete trackingData.pressTargetsByButton[from.button]; } + this.emitPointerInput(e, 'pointerup'); this.freeEvent(e); }; @@ -648,7 +914,7 @@ export class EventManager { event.nativeEvent = from.nativeEvent; event.originalEvent = from; - if (target) { + if (target !== undefined) { event.target = target; } else { event.target = this.pickTarget(event.viewX ?? event.global.x, event.viewY ?? event.global.y, event); @@ -757,6 +1023,9 @@ export class EventManager { protected trackingData(id: number): TrackingData { if (!this.mappingState.trackingData[id]) { this.mappingState.trackingData[id] = { + generation: 0, + inside: false, + previousInside: false, pressTargetsByButton: {}, clicksByButton: {}, overTarget: null @@ -783,6 +1052,11 @@ export class EventManager { } protected freeEvent(event: T): void { + event.nativeEvent = null; + event.originalEvent = null; + if (!this.rootTarget) { + return; + } if (event.manager !== this) { throw new Error('It is illegal to free an event not managed by this EventManager!'); } @@ -804,6 +1078,9 @@ export class EventManager { } private notifyListeners(e: FederatedEvent, type: string): void { + if (!this.inputValid() || !e.currentTarget) { + return; + } const events = (e.currentTarget as any)._events as EmitterListeners; const listeners = events[type]; @@ -814,7 +1091,7 @@ export class EventManager { } listeners.fn.call(listeners.context, e); } else { - for (let i = 0, j = listeners.length; i < j && !e.propagationImmediatelyStopped; i++) { + for (let i = 0, j = listeners.length; i < j && this.inputValid() && !e.propagationImmediatelyStopped; i++) { if (listeners[i].once) { e.currentTarget.removeEventListener(type, listeners[i].fn, { once: true }); } @@ -823,17 +1100,22 @@ export class EventManager { } } // 永远触发WILDCARD事件代理 - this.emitDelegation(e, type); + if (this.inputValid()) { + this.emitDelegation(e, type); + } } private emitDelegation(e: FederatedEvent, type: string): void { + if (!this.inputValid() || !e.currentTarget) { + return; + } const events = (e.currentTarget as any)._events as EmitterListeners; const listeners = events[WILDCARD]; if (listeners) { if ('fn' in listeners) { listeners.fn.call(listeners.context, e, type); } else { - for (let i = 0, j = listeners.length; i < j && !e.propagationImmediatelyStopped; i++) { + for (let i = 0, j = listeners.length; i < j && this.inputValid() && !e.propagationImmediatelyStopped; i++) { listeners[i].fn.call(listeners[i].context, e, type); } } @@ -866,7 +1148,10 @@ export class EventManager { this.eventPool.clear(); this.rootTarget = null; this.mappingTable = null; - this.mappingState = null; + this.mappingState = { trackingData: {} }; + this.canvasInput.clear(); + this.windowInput.clear(); + this.dispatchingEvent?.stopImmediatePropagation(); this.cursorTarget = null; } } diff --git a/packages/vrender-core/src/event/event-system.ts b/packages/vrender-core/src/event/event-system.ts index b71e88aca..de58dd758 100644 --- a/packages/vrender-core/src/event/event-system.ts +++ b/packages/vrender-core/src/event/event-system.ts @@ -4,7 +4,14 @@ import type { IGlobal, IWindow } from '../interface'; import { EventManager } from './event-manager'; import { FederatedPointerEvent, FederatedWheelEvent } from './federated-event'; import type { FederatedMouseEvent } from './federated-event/mouse-event'; -import type { EventPoint, IElementLike, IEventTarget, NativeEvent, RenderConfig } from '../interface/event'; +import type { + EventPoint, + IElementLike, + IEventTarget, + NativeEvent, + RenderConfig, + HostInputOptions +} from '../interface/event'; import { clock } from './util'; const MOUSE_POINTER_ID = 1; @@ -90,6 +97,7 @@ export class EventSystem { private rootPointerEvent: FederatedPointerEvent; private rootWheelEvent: FederatedWheelEvent; private eventsAdded: boolean; + private readonly useNativeEvents: boolean; constructor(params: RenderConfig) { const { @@ -124,16 +132,25 @@ export class EventSystem { pointer: 'pointer' }; + this.useNativeEvents = params.useNativeEvents !== false; this.resolution = resolution; this.setTargetElement(targetElement); } release(): void { - this.removeEvents(); - this.manager && this.manager.release(); - this.domElement = null; - (this as any).manager = null; - (this as any).globalObj = null; + if (this.released) { + return; + } + this.released = true; + this.pendingInputs = undefined; + try { + this.manager.cancelAllPointers(); + } finally { + this.removeEvents(); + this.manager.release(); + this.domElement = null; + (this as any).globalObj = null; + } } setCursor(mode: string, target: IEventTarget | null | 'ignore'): void { @@ -164,98 +181,127 @@ export class EventSystem { } } - private onPointerDown = (nativeEvent: NativeEvent): void => { - if (this.supportsTouchEvents && (nativeEvent as PointerEvent).pointerType === 'touch') { - return; - } - - const events = this.normalizeToPointerData(nativeEvent); - - if (this.autoPreventDefault && (events[0] as any).isNormalized) { - const cancelable = nativeEvent.cancelable || !('cancelable' in nativeEvent); - - if (cancelable) { - nativeEvent.preventDefault(); - } - } - - for (let i = 0, j = events.length; i < j; i++) { - const nativeEvent = events[i]; - const federatedEvent = this.bootstrapEvent(this.rootPointerEvent, nativeEvent); - - this.manager.mapEvent(federatedEvent); - } + /** The window scope is this Stage's accepted input, not the browser's unfiltered window. */ + get input() { + return this.manager.input; + } - this.setCursor(this.manager.cursor, this.manager.cursorTarget); - // 避免内存泄露 - this.rootPointerEvent.nativeEvent = null; - }; + private released = false; + private processingInput = false; + private pendingInputs?: { event: NativeEvent | WheelEvent; options?: HostInputOptions }[]; - private onPointerMove = (nativeEvent: NativeEvent): void => { - if (this.supportsTouchEvents && (nativeEvent as PointerEvent).pointerType === 'touch') { + /** Ignoring an input and cancelling a gesture are separate host decisions. */ + handleNativeEvent(event: NativeEvent | WheelEvent, options?: HostInputOptions): void { + if (this.released) { return; } - - if (this.isEventOutsideOfTargetElement(nativeEvent)) { + if (this.processingInput) { + // Allocate only for reentrant input. Finish the old transaction before starting a new gesture. + (this.pendingInputs ??= []).push({ + event, + options: options && { + canvasPoint: { x: options.canvasPoint.x, y: options.canvasPoint.y }, + inViewport: options.inViewport + } + }); return; } - - const normalizedEvents = this.normalizeToPointerData(nativeEvent); - for (let i = 0, j = normalizedEvents.length; i < j; i++) { - const event = this.bootstrapEvent(this.rootPointerEvent, normalizedEvents[i]); - - this.manager.mapEvent(event); + this.processingInput = true; + try { + this.processInput(event, options); + this.drainInputQueue(); + } finally { + this.processingInput = false; + this.pendingInputs = undefined; + this.rootPointerEvent.nativeEvent = null; + this.rootWheelEvent.nativeEvent = null; } + } - this.setCursor(this.manager.cursor, this.manager.cursorTarget); - // 避免内存泄露 - this.rootPointerEvent.nativeEvent = null; - }; + cancelPointer(pointerId: number): void { + this.cancelInput(pointerId); + } + + cancelAllPointers(): void { + this.cancelInput(); + } - private onPointerUp = (nativeEvent: NativeEvent): void => { - if (this.supportsTouchEvents && (nativeEvent as PointerEvent).pointerType === 'touch') { + private cancelInput(pointerId?: number): void { + if (this.released) { return; } - - const outside = this.isEventOutsideOfTargetViewPort(nativeEvent) ? 'outside' : ''; - const normalizedEvents = this.normalizeToPointerData(nativeEvent); - - for (let i = 0, j = normalizedEvents.length; i < j; i++) { - const event = this.bootstrapEvent(this.rootPointerEvent, normalizedEvents[i]); - - event.type += outside; - - this.manager.mapEvent(event); + const processing = this.processingInput; + this.processingInput = true; + try { + if (pointerId === undefined) { + this.manager.cancelAllPointers(); + } else { + this.manager.cancelPointer(pointerId); + } + if (!processing) { + this.drainInputQueue(); + } + } finally { + this.processingInput = processing; + if (!processing) { + this.pendingInputs = undefined; + this.rootPointerEvent.nativeEvent = null; + this.rootWheelEvent.nativeEvent = null; + } } + } - this.setCursor(this.manager.cursor, this.manager.cursorTarget); - // 避免内存泄露 - this.rootPointerEvent.nativeEvent = null; - }; + private drainInputQueue(): void { + while (!this.released && this.pendingInputs?.length) { + const next = this.pendingInputs.shift(); + this.processInput(next.event, next.options); + } + } - private onPointerOverOut = (nativeEvent: NativeEvent): void => { - if (this.supportsTouchEvents && (nativeEvent as PointerEvent).pointerType === 'touch') { + private processInput(nativeEvent: NativeEvent | WheelEvent, options?: HostInputOptions): void { + if (!options && this.supportsTouchEvents && (nativeEvent as PointerEvent).pointerType === 'touch') { return; } - - const normalizedEvents = this.normalizeToPointerData(nativeEvent); - - for (let i = 0, j = normalizedEvents.length; i < j; i++) { - const event = this.bootstrapEvent(this.rootPointerEvent, normalizedEvents[i]); - - this.manager.mapEvent(event); + if (nativeEvent.type === 'wheel') { + const event = this.normalizeWheelEvent(nativeEvent as WheelEvent, options?.canvasPoint); + if (options?.inViewport ?? !this.isEventOutsideOfTargetViewPort(nativeEvent, event)) { + this.manager.mapEvent(event); + } + return; } + const events = this.normalizeToPointerData(nativeEvent); + if (this.autoPreventDefault && (events[0] as VRenderPointerEvent)?.isNormalized && nativeEvent.cancelable) { + nativeEvent.preventDefault(); + } + for (let i = 0; i < events.length && !this.released; i++) { + const event = this.bootstrapEvent(this.rootPointerEvent, events[i], options?.canvasPoint); + // Keep the original TouchEvent so synchronous preventDefault reaches the browser. + event.nativeEvent = nativeEvent; + if (event.type === 'pointercancel') { + this.manager.cancelPointer(event.pointerId); + continue; + } + const inside = + event.type !== 'pointerout' && + event.type !== 'pointerleave' && + (options?.inViewport ?? !this.isEventOutsideOfTargetViewPort(nativeEvent, event)); + if (!inside && (event.type === 'pointerdown' || !this.manager.hasPointer(event.pointerId))) { + continue; + } + this.manager.mapEvent(event, inside); + } + if (!options && !this.released) { + this.setCursor(this.manager.cursor, this.manager.cursorTarget); + } + } - this.setCursor(this.manager.cursor, this.manager.cursorTarget); - // 避免内存泄露 - this.rootPointerEvent.nativeEvent = null; - }; - - protected onWheel = (nativeEvent: WheelEvent): void => { - const wheelEvent = this.normalizeWheelEvent(nativeEvent); - - this.manager.mapEvent(wheelEvent); - }; + private onPointerDown = (event: NativeEvent): void => this.handleNativeEvent(event); + private onPointerMove = (event: NativeEvent): void => this.handleNativeEvent(event); + private onPointerUp = (event: NativeEvent): void => this.handleNativeEvent(event); + private onPointerCancel = (event: NativeEvent): void => this.handleNativeEvent(event); + private onPointerOverOut = (event: NativeEvent): void => this.handleNativeEvent(event); + protected onWheel = (event: WheelEvent): void => this.handleNativeEvent(event); + private onBlur = (): void => this.cancelAllPointers(); setTargetElement(element: IElementLike | null): void { this.removeEvents(); @@ -264,7 +310,7 @@ export class EventSystem { } private addEvents(): void { - if (this.eventsAdded || !this.domElement) { + if (!this.useNativeEvents || this.eventsAdded || !this.domElement) { return; } const { globalObj, domElement } = this; @@ -273,9 +319,11 @@ export class EventSystem { if (globalObj.getDocument()) { globalObj.addEventListener('pointermove', this.onPointerMove, true); globalObj.addEventListener('pointerup', this.onPointerUp, true); + globalObj.addEventListener('pointercancel', this.onPointerCancel, true); } else { domElement.addEventListener('pointermove', this.onPointerMove, true); domElement.addEventListener('pointerup', this.onPointerUp, true); + domElement.addEventListener('pointercancel', this.onPointerCancel, true); } domElement.addEventListener('pointerdown', this.onPointerDown, true); domElement.addEventListener('pointerleave', this.onPointerOverOut, true); @@ -296,13 +344,15 @@ export class EventSystem { if (this.supportsTouchEvents) { domElement.addEventListener('touchstart', this.onPointerDown, true); domElement.addEventListener('touchend', this.onPointerUp, true); - domElement.addEventListener('touchmove', this.onPointerMove, true); + domElement.addEventListener('touchcancel', this.onPointerCancel, true); + domElement.addEventListener('touchmove', this.onPointerMove, { capture: true, passive: false }); } domElement.addEventListener('wheel', this.onWheel, { capture: true }); + globalObj.getDocument?.()?.defaultView?.addEventListener('blur', this.onBlur); this.eventsAdded = true; } @@ -311,15 +361,18 @@ export class EventSystem { return; } const { globalObj, domElement } = this; + globalObj.getDocument?.()?.defaultView?.removeEventListener('blur', this.onBlur); // const globalDocument = globalObj.getDocument() ?? domElement; if (this.supportsPointerEvents) { if (globalObj.getDocument()) { globalObj.removeEventListener('pointermove', this.onPointerMove, true); globalObj.removeEventListener('pointerup', this.onPointerUp, true); + globalObj.removeEventListener('pointercancel', this.onPointerCancel, true); } else { domElement.removeEventListener('pointermove', this.onPointerMove, true); domElement.removeEventListener('pointerup', this.onPointerUp, true); + domElement.removeEventListener('pointercancel', this.onPointerCancel, true); } domElement.removeEventListener('pointerdown', this.onPointerDown, true); domElement.removeEventListener('pointerleave', this.onPointerOverOut, true); @@ -340,6 +393,7 @@ export class EventSystem { if (this.supportsTouchEvents) { domElement.removeEventListener('touchstart', this.onPointerDown, true); domElement.removeEventListener('touchend', this.onPointerUp, true); + domElement.removeEventListener('touchcancel', this.onPointerCancel, true); domElement.removeEventListener('touchmove', this.onPointerMove, true); } @@ -486,7 +540,7 @@ export class EventSystem { return normalizedEvents as PointerEvent[]; } - protected normalizeWheelEvent(nativeEvent: WheelEvent): FederatedWheelEvent { + protected normalizeWheelEvent(nativeEvent: WheelEvent, canvasPoint?: EventPoint): FederatedWheelEvent { const event = this.rootWheelEvent; this.transferMouseData(event, nativeEvent); @@ -497,7 +551,7 @@ export class EventSystem { event.deltaZ = nativeEvent.deltaZ; // 获取相对画布坐标 - const { x: canvasX, y: canvasY } = this.mapToCanvasPoint(nativeEvent); + const { x: canvasX, y: canvasY } = canvasPoint ?? this.mapToCanvasPoint(nativeEvent); event.canvas.x = canvasX; event.canvas.y = canvasY; @@ -523,7 +577,11 @@ export class EventSystem { * @param event * @param nativeEvent */ - private bootstrapEvent(event: FederatedPointerEvent, nativeEvent: PointerEvent): FederatedPointerEvent { + private bootstrapEvent( + event: FederatedPointerEvent, + nativeEvent: PointerEvent, + canvasPoint?: EventPoint + ): FederatedPointerEvent { event.originalEvent = null; event.nativeEvent = nativeEvent; @@ -539,7 +597,7 @@ export class EventSystem { event.twist = nativeEvent.twist; this.transferMouseData(event, nativeEvent); - const { x: canvasX, y: canvasY } = this.mapToCanvasPoint(nativeEvent); + const { x: canvasX, y: canvasY } = canvasPoint ?? this.mapToCanvasPoint(nativeEvent); event.canvas.x = canvasX; event.canvas.y = canvasY; @@ -594,14 +652,14 @@ export class EventSystem { event.relatedTarget = null; } - private isEventOutsideOfTargetViewPort(nativeEvent: NativeEvent) { + private isEventOutsideOfTargetViewPort(nativeEvent: NativeEvent, event: FederatedMouseEvent) { if (this.isEventOutsideOfTargetElement(nativeEvent)) { return true; } // 判断点是否在区间内 if ((this.domElement as IWindow).getViewBox) { - const p = this.mapToViewportPoint(this.mapToCanvasPoint(nativeEvent as any)); + const p = event.viewport; const b = (this.domElement as IWindow).getViewBox(); const w = b.width(); const h = b.height(); diff --git a/packages/vrender-core/src/event/federated-event/base-event.ts b/packages/vrender-core/src/event/federated-event/base-event.ts index b0f18f0e7..0d573c093 100644 --- a/packages/vrender-core/src/event/federated-event/base-event.ts +++ b/packages/vrender-core/src/event/federated-event/base-event.ts @@ -206,7 +206,7 @@ export class FederatedEvent implements Event { this.nativeEvent.preventDefault(); } } catch (err) { - this.nativeEvent.preventDefault && + this.nativeEvent?.preventDefault && isFunction(this.nativeEvent.preventDefault) && this.nativeEvent.preventDefault(); } diff --git a/packages/vrender-core/src/event/input-source.ts b/packages/vrender-core/src/event/input-source.ts new file mode 100644 index 000000000..7846ad8cd --- /dev/null +++ b/packages/vrender-core/src/event/input-source.ts @@ -0,0 +1,39 @@ +import type { IFederatedMouseEvent, InputEventSource } from '../interface/event'; + +type Listener = (event: IFederatedMouseEvent) => void; + +/** Copy-on-write subscriptions: dispatch allocates nothing and cancellation can stop remaining listeners. */ +export class InputSource { + private listeners: Record = {}; + readonly source: InputEventSource = { + on: (type, listener) => { + this.listeners[type] = (this.listeners[type] ?? []).concat(listener); + }, + off: (type, listener) => { + const list = this.listeners[type]; + if (list) { + this.listeners[type] = list.filter(fn => fn !== listener); + } + } + }; + + emit(type: string, event: IFederatedMouseEvent, valid: () => boolean): void { + const list = this.listeners[type]; + if (!list) { + return; + } + const originalType = event.type; + event.type = type; + try { + for (let i = 0; i < list.length && valid(); i++) { + list[i](event); + } + } finally { + event.type = originalType; + } + } + + clear(): void { + this.listeners = {}; + } +} diff --git a/packages/vrender-core/src/interface/event.ts b/packages/vrender-core/src/interface/event.ts index 485c37c57..0802bd0ba 100644 --- a/packages/vrender-core/src/interface/event.ts +++ b/packages/vrender-core/src/interface/event.ts @@ -214,6 +214,7 @@ export type IElementLike = Omit void): void; + off(type: string, listener: (event: IFederatedMouseEvent) => void): void; +} diff --git a/packages/vrender-core/src/interface/stage.ts b/packages/vrender-core/src/interface/stage.ts index 181d9a16c..229639a3f 100644 --- a/packages/vrender-core/src/interface/stage.ts +++ b/packages/vrender-core/src/interface/stage.ts @@ -1,4 +1,5 @@ import type { INode } from './node-tree'; +import type { IGroup } from './graphic/group'; import type { ILayer, LayerMode } from './layer'; import type { IColor } from './color'; import type { IAABBBounds, IBounds, IBoundsLike, IMatrix } from '@visactor/vutils'; @@ -21,6 +22,14 @@ export type IExportType = 'canvas' | 'imageData'; export type IStageCreateContext = { appName?: 'vchart' | 'vgrammar' | 'vtable' | string; }; +/** Options for drawing a stage into another window. Omitted fields use the target window geometry. */ +export interface IRenderToOptions { + viewBox?: IBounds; + transMatrix?: IMatrix; + /** Clear the destination before the first layer. Defaults to true. */ + clear?: boolean; +} + export interface IStageParams { // x: number; // y: number; @@ -51,8 +60,12 @@ export interface IStageParams { enableLayout: boolean; // 是否关闭脏矩形检测 disableDirtyBounds: boolean; - // 是否支持interactiveLayer,默认为true + // 是否支持独立交互 Layer,默认为 true。 interactiveLayer: boolean; + /** 交互层的渲染模式;缺省沿用环境默认,virtual 复用主层 Canvas,在首帧准备前创建。 */ + interactiveLayerMode?: 'static' | 'virtual'; + /** Delegate invalidation to an external compositor; paint explicitly with renderTo. */ + requestRender?: () => void; // 是否支持HTML属性 enableHtmlAttribute: string | boolean | HTMLElement; // 是否支持react-dom(传入ReactDOM) @@ -98,6 +111,8 @@ export interface IStageParams { } export type EventConfig = { + /** 设为 false 时保留事件管理器,由宿主输入事件,不绑定默认 DOM 监听。 */ + useNativeEvents?: boolean; /** 是否自动阻止事件 */ autoPreventDefault?: boolean; /** @@ -224,7 +239,12 @@ export interface IStage extends INode { dirty: (b: IBounds, matrix?: IMatrix) => void; // 考虑操作回放 - renderTo: (window: IWindow, params: { x: number; y: number; width: number; height: number }) => void; + // The legacy rectangle argument is retained unchanged; drawing options belong to the third argument. + renderTo: ( + window: IWindow, + params?: { x: number; y: number; width: number; height: number }, + options?: IRenderToOptions + ) => void; renderToNewWindow: (fullImage?: boolean) => IWindow; diff --git a/packages/vrender-core/src/render/contributions/render/draw-interceptor.ts b/packages/vrender-core/src/render/contributions/render/draw-interceptor.ts index 22e3261ba..3ae557ad3 100644 --- a/packages/vrender-core/src/render/contributions/render/draw-interceptor.ts +++ b/packages/vrender-core/src/render/contributions/render/draw-interceptor.ts @@ -417,16 +417,26 @@ export class InteractiveDrawItemInterceptorContribution implements IDrawItemInte this.processing = true; const { context } = drawContext; context.highPerformanceSave(); - // 直接transform - context.setTransformFromMatrix(baseGraphic.parent.globalTransMatrix, true); - // context.fillRect(0, 0, 100, 100); - // 设置context的transform到上一个节点 - baseGraphic.isContainer - ? drawContribution.renderGroup(baseGraphic as IGroup, drawContext, baseGraphic.parent.globalTransMatrix) - : drawContribution.renderItem(baseGraphic, drawContext); - - context.highPerformanceRestore(); - this.processing = false; + // renderTo 的目标变换必须同时作用于提升后的图元;不修改原图元祖先矩阵。 + const parent = baseGraphic.parent.globalTransMatrix; + const matrix = matrixAllocate.allocateByObj(parent); + if (drawContext.transMatrix) { + const outer = drawContext.transMatrix; + matrix.setValue(outer.a, outer.b, outer.c, outer.d, outer.e, outer.f); + matrix.multiply(parent.a, parent.b, parent.c, parent.d, parent.e, parent.f); + } + try { + context.setTransformFromMatrix(matrix, true); + // context.fillRect(0, 0, 100, 100); + // 设置context的transform到上一个节点 + baseGraphic.isContainer + ? drawContribution.renderGroup(baseGraphic as IGroup, drawContext, matrix) + : drawContribution.renderItem(baseGraphic, drawContext); + } finally { + context.highPerformanceRestore(); + matrixAllocate.free(matrix); + this.processing = false; + } return true; }