Skip to content

Write HTML. Render video. Built for agents.

fix(studio): the timeline follows a paused playhead and zoom keeps it in place (#4712)

Miguel Ángel3c771120c9ea
diff --git a/packages/studio/src/components/TimelineToolbar.test.tsx b/packages/studio/src/components/TimelineToolbar.test.tsx
index bc6132cc43..e309d5b977 100644
--- a/packages/studio/src/components/TimelineToolbar.test.tsx
+++ b/packages/studio/src/components/TimelineToolbar.test.tsx
@@ -226,6 +226,18 @@ describe("TimelineToolbar Fit", () => {
expect(fit()?.getAttribute("aria-pressed")).toBe("false");
act(() => root.unmount());
});
+
+ it("counts a zoom-in click as a person's zoom, so the timeline anchors it on the playhead", () => {
+ const { host, root } = renderToolbar();
+ const before = usePlayerStore.getState().userZoomCount;
+ act(() =>
+ host
+ .querySelector('button[aria-label="Zoom in"]')
+ ?.dispatchEvent(new MouseEvent("click", { bubbles: true })),
+ );
+ expect(usePlayerStore.getState().userZoomCount).toBe(before + 1);
+ act(() => root.unmount());
+ });
});
describe("TimelineToolbar audio meters", () => {
diff --git a/packages/studio/src/components/nle/NLEContext.tsx b/packages/studio/src/components/nle/NLEContext.tsx
index ab85f68caf..c09ed2735d 100644
--- a/packages/studio/src/components/nle/NLEContext.tsx
+++ b/packages/studio/src/components/nle/NLEContext.tsx
@@ -21,7 +21,7 @@ export interface NLEContextValue {
play: () => void;
pause: () => void;
togglePlay: () => void;
- seek: (time: number, options?: { keepPlaying?: boolean }) => boolean;
+ seek: (time: number, options?: { keepPlaying?: boolean; follow?: boolean }) => boolean;
refreshPlayer: () => void;
onIframeLoad: () => void;
// The hidden reload iframe NLEPreview renders next to the live one during a full reload.
diff --git a/packages/studio/src/player/components/TimelineTypes.ts b/packages/studio/src/player/components/TimelineTypes.ts
index f5aa1e03d0..460fef28c9 100644
--- a/packages/studio/src/player/components/TimelineTypes.ts
+++ b/packages/studio/src/player/components/TimelineTypes.ts
@@ -15,7 +15,7 @@ export interface TimelineProps
extends TimelineDropCallbacks, TimelineEditOverrides, TimelineStackingSyncProps {
/** Project-scoped reset boundary; soft source refreshes retain the same epoch. */
sessionEpoch?: number;
- onSeek?: (time: number, options?: { keepPlaying?: boolean }) => void;
+ onSeek?: (time: number, options?: { keepPlaying?: boolean; follow?: boolean }) => void;
onDrillDown?: (element: TimelineElement) => void;
/** Picture only: takes no pointer input. Interactive content goes in renderClipOverlay. */
renderClipContent?: (
diff --git a/packages/studio/src/player/components/useTimelineClipDrag.resize.test.tsx b/packages/studio/src/player/components/useTimelineClipDrag.resize.test.tsx
index fd5cb0fadd..2aa3718dd1 100644
--- a/packages/studio/src/player/components/useTimelineClipDrag.resize.test.tsx
+++ b/packages/studio/src/player/components/useTimelineClipDrag.resize.test.tsx
@@ -513,9 +513,9 @@ describe("useTimelineClipDrag — trim guide and preview frame", () => {
const h = renderResizeHarness([a], [], { onSeek });
h.startResize(a, "end");
h.movePointer(50);
- expect(onSeek).toHaveBeenLastCalledWith(3.5 - 1 / 30, { keepPlaying: true });
+ expect(onSeek).toHaveBeenLastCalledWith(3.5 - 1 / 30, { keepPlaying: true, follow: false });
await h.dropPointer();
- expect(onSeek).toHaveBeenLastCalledWith(1.25, { keepPlaying: true });
+ expect(onSeek).toHaveBeenLastCalledWith(1.25, { keepPlaying: true, follow: false });
h.unmount();
});
@@ -525,7 +525,7 @@ describe("useTimelineClipDrag — trim guide and preview frame", () => {
const h = renderResizeHarness([a], [], { onSeek });
h.startResize(a, "start");
h.movePointer(50);
- expect(onSeek).toHaveBeenLastCalledWith(1.5, { keepPlaying: true });
+ expect(onSeek).toHaveBeenLastCalledWith(1.5, { keepPlaying: true, follow: false });
h.unmount();
});
@@ -545,7 +545,7 @@ describe("useTimelineClipDrag — trim guide and preview frame", () => {
h.movePointer(80);
h.movePointer(120);
await h.dropPointer();
- expect(onSeek).toHaveBeenLastCalledWith(1.25, { keepPlaying: true });
+ expect(onSeek).toHaveBeenLastCalledWith(1.25, { keepPlaying: true, follow: false });
h.unmount();
});
@@ -571,7 +571,10 @@ describe("useTimelineClipDrag — trim guide and preview frame", () => {
const clip = h.getResizingClip()!;
expect(clip.previewStart + clip.previewDuration).toBeCloseTo(3.1, 3);
expect(clip).toMatchObject({ snapTime: null, snapType: null });
- expect(onSeek).toHaveBeenLastCalledWith(expect.closeTo(3.1 - 1 / 30, 3), { keepPlaying: true });
+ expect(onSeek).toHaveBeenLastCalledWith(expect.closeTo(3.1 - 1 / 30, 3), {
+ keepPlaying: true,
+ follow: false,
+ });
h.unmount();
});
});
diff --git a/packages/studio/src/player/components/useTimelineClipDrag.ts b/packages/studio/src/player/components/useTimelineClipDrag.ts
index 7c49eda117..18e588d747 100644
--- a/packages/studio/src/player/components/useTimelineClipDrag.ts
+++ b/packages/studio/src/player/components/useTimelineClipDrag.ts
@@ -66,7 +66,7 @@ interface UseTimelineClipDragInput {
onResizeElements?: NonNullable<TimelineEditCallbacks["onResizeElements"]>;
onBlockedEditAttempt?: (element: TimelineElement, intent: BlockedClipState["intent"]) => void;
/** Seeks the preview; a trim shows the frame at its dragged edge. */
- onSeek?: (time: number, options?: { keepPlaying?: boolean }) => void;
+ onSeek?: (time: number, options?: { keepPlaying?: boolean; follow?: boolean }) => void;
setShowPopover: (show: boolean) => void;
/** Stable ref to the range selection setter — wired after mount to break circular dependency. */
setRangeSelectionRef: React.RefObject<((sel: null) => void) | null>;
@@ -311,6 +311,7 @@ export function useTimelineClipDrag({
// and it only resumes playback if it was already playing.
onSeekRef.current?.(trimPreviewTime(resize.edge, v.previewStart, v.previewDuration), {
keepPlaying: true,
+ follow: false,
});
publishResizingClip(
resizingClipRef.current ? { ...resizingClipRef.current, started: true, ...v } : null,
@@ -361,7 +362,7 @@ export function useTimelineClipDrag({
if (trimSeekOriginRef.current != null) {
// Paused: put the playhead back. Playing: leave it, a backward jump would rewind live playback.
if (!usePlayerStore.getState().isPlaying) {
- onSeekRef.current?.(trimSeekOriginRef.current, { keepPlaying: true });
+ onSeekRef.current?.(trimSeekOriginRef.current, { keepPlaying: true, follow: false });
}
trimSeekOriginRef.current = null;
}
diff --git a/packages/studio/src/player/components/useTimelinePlayhead.test.tsx b/packages/studio/src/player/components/useTimelinePlayhead.test.tsx
index a6096a3b25..33dcde8973 100644
--- a/packages/studio/src/player/components/useTimelinePlayhead.test.tsx
+++ b/packages/studio/src/player/components/useTimelinePlayhead.test.tsx
@@ -1,12 +1,15 @@
// @vitest-environment happy-dom
-import { act, createRef } from "react";
-import { createRoot } from "react-dom/client";
-import { describe, expect, it } from "vitest";
+import { act, useRef } from "react";
+import { createRoot, type Root } from "react-dom/client";
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
+import { liveTime, usePlayerStore, type ZoomMode } from "../store/playerStore";
import { useTimelinePlayhead } from "./useTimelinePlayhead";
Object.assign(globalThis, { IS_REACT_ACT_ENVIRONMENT: true });
+const ORIGIN = 32;
+
function scrollBox(scrollLeft: number) {
const el = document.createElement("div");
let left = scrollLeft;
@@ -18,18 +21,34 @@ function scrollBox(scrollLeft: number) {
return el;
}
-function Harness({ pps, scroll }: { pps: number; scroll: HTMLDivElement }) {
+interface HarnessProps {
+ pps: number;
+ scroll: HTMLDivElement;
+ percent?: number;
+ dragging?: boolean;
+ zoomMode?: ZoomMode;
+}
+
+function Harness({
+ pps,
+ scroll,
+ percent = 100,
+ dragging = false,
+ zoomMode = "manual",
+}: HarnessProps) {
+ const scrollRef = useRef(scroll);
+ const durationRef = useRef(60);
useTimelinePlayhead({
- playheadRef: createRef(),
- scrollRef: { current: scroll },
+ playheadRef: { current: document.createElement("div") },
+ scrollRef,
ppsRef: { current: pps },
- durationRef: { current: 60 },
- isDragging: { current: false },
+ durationRef,
+ isDragging: { current: dragging },
currentTime: 0,
- zoomMode: "manual",
- manualZoomPercent: 100,
- zoomModeRef: { current: "manual" },
- manualZoomPercentRef: { current: 100 },
+ zoomMode,
+ manualZoomPercent: percent,
+ zoomModeRef: { current: zoomMode },
+ manualZoomPercentRef: { current: percent },
fitPps: pps,
fitPpsRef: { current: pps },
effectiveDuration: 60,
@@ -38,28 +57,198 @@ function Harness({ pps, scroll }: { pps: number; scroll: HTMLDivElement }) {
elementsLength: 1,
setZoomMode: () => {},
setManualZoomPercent: () => {},
- contentOrigin: 32,
+ contentOrigin: ORIGIN,
});
return null;
}
-function zoom(scrollLeft: number, fromPps: number, toPps: number) {
- const scroll = scrollBox(scrollLeft);
- const host = document.createElement("div");
- const root = createRoot(host);
- act(() => root.render(<Harness pps={fromPps} scroll={scroll} />));
- act(() => root.render(<Harness pps={toPps} scroll={scroll} />));
- act(() => root.unmount());
- return scroll.scrollLeft;
+const roots: Root[] = [];
+function mount(props: HarnessProps) {
+ const root = createRoot(document.createElement("div"));
+ roots.push(root);
+ act(() => root.render(<Harness {...props} />));
+ return (next: Partial<HarnessProps>, byPerson = false) =>
+ act(() => {
+ if (byPerson) usePlayerStore.setState((s) => ({ userZoomCount: s.userZoomCount + 1 }));
+ root.render(<Harness {...props} {...next} />);
+ });
}
-describe("useTimelinePlayhead centre anchor", () => {
- it("keeps a view at the start at the start when the scale changes", () => {
- expect(zoom(0, 100, 114)).toBe(0);
+beforeEach(() => {
+ usePlayerStore.setState({ currentTime: 0, isPlaying: false, beatDragging: false });
+});
+afterEach(() => {
+ for (const root of roots.splice(0)) act(() => root.unmount());
+});
+
+/** Where the playhead at `time` sits inside the 800px viewport. */
+const onScreenX = (scroll: HTMLDivElement, time: number, pps: number) =>
+ ORIGIN + time * pps - scroll.scrollLeft;
+function expectVisible(scroll: HTMLDivElement, time: number, pps: number) {
+ const x = onScreenX(scroll, time, pps);
+ expect(x).toBeGreaterThanOrEqual(ORIGIN);
+ expect(x).toBeLessThanOrEqual(800);
+}
+
+describe("useTimelinePlayhead zoom anchor", () => {
+ it("keeps a view at the start at the start when the window resizes", () => {
+ const scroll = scrollBox(0);
+ mount({ pps: 100, scroll })({ pps: 114 });
+ expect(scroll.scrollLeft).toBe(0);
});
- it("keeps the time at the viewport centre when the view is scrolled", () => {
+ it("keeps the time at the viewport centre when a scrolled window resizes", () => {
+ const scroll = scrollBox(400);
// Centre time (400 + 400 - 32) / 100 = 7.68s lands at 32 + 7.68 * 200 - 400.
- expect(zoom(400, 100, 200)).toBe(1168);
+ mount({ pps: 100, scroll })({ pps: 200 });
+ expect(scroll.scrollLeft).toBe(1168);
+ });
+
+ it("keeps a view at 00:00 on a resize even when the playhead is mid-film", () => {
+ usePlayerStore.setState({ currentTime: 6 });
+ const scroll = scrollBox(0);
+ mount({ pps: 100, scroll })({ pps: 150 });
+ expect(scroll.scrollLeft).toBe(0);
+ });
+
+ it("keeps the playhead where it is on screen when the toolbar zooms", () => {
+ usePlayerStore.setState({ currentTime: 6 });
+ const scroll = scrollBox(400);
+ const before = onScreenX(scroll, 6, 100);
+ mount({ pps: 100, scroll, percent: 100 })({ pps: 200, percent: 200 }, true);
+ expect(onScreenX(scroll, 6, 200)).toBeCloseTo(before);
+ });
+
+ it("stays at 00:00 when a zoom is set with the playhead at 0, as a zoom restored on open is", () => {
+ const scroll = scrollBox(0);
+ mount({ pps: 100, scroll, percent: 100 })({ pps: 250, percent: 250 }, true);
+ expect(scroll.scrollLeft).toBe(0);
+ });
+
+ it("keeps the centre on a resize after a toolbar zoom that hit the zoom limit", () => {
+ usePlayerStore.setState({ currentTime: 6 });
+ const scroll = scrollBox(400);
+ const update = mount({ pps: 100, scroll });
+ update({}, true);
+ update({ pps: 200 });
+ expect(scroll.scrollLeft).toBe(1168);
+ });
+
+ it("brings an off-screen playhead into view when the toolbar zooms", () => {
+ usePlayerStore.setState({ currentTime: 30 });
+ const scroll = scrollBox(0);
+ mount({ pps: 100, scroll, percent: 100 })({ pps: 200, percent: 200 }, true);
+ expectVisible(scroll, 30, 200);
+ });
+});
+
+describe("useTimelinePlayhead zoom anchor, percent written by Studio itself", () => {
+ it("keeps 00:00 when the window resizes after an edit pinned the zoom", () => {
+ usePlayerStore.setState({ currentTime: 6 });
+ const scroll = scrollBox(0);
+ const update = mount({ pps: 100, scroll, percent: 200 });
+ update({ percent: 100 });
+ update({ pps: 130, percent: 100 });
+ expect(scroll.scrollLeft).toBe(0);
+ });
+
+ it("leaves an off-screen playhead alone when a length change re-pins the zoom", () => {
+ usePlayerStore.setState({ currentTime: 30 });
+ const scroll = scrollBox(400);
+ const update = mount({ pps: 100, scroll, percent: 150 });
+ update({ pps: 90, percent: 150 });
+ update({ pps: 101, percent: 168 });
+ const x = onScreenX(scroll, 30, 101);
+ expect(x > 800 || x < ORIGIN).toBe(true);
+ });
+
+ it("anchors a person's zoom that lands on the percent already stored", () => {
+ usePlayerStore.setState({ currentTime: 30 });
+ const scroll = scrollBox(0);
+ mount({ pps: 100, scroll, percent: 200 })({ pps: 200, percent: 200 }, true);
+ expectVisible(scroll, 30, 200);
+ });
+});
+
+describe("useTimelinePlayhead follow while paused", () => {
+ it("scrolls a paused seek that lands off screen into view", () => {
+ const scroll = scrollBox(0);
+ mount({ pps: 100, scroll });
+ act(() => liveTime.notifySeek(30));
+ expectVisible(scroll, 30, 100);
+ });
+
+ it("leaves the view alone when a paused seek lands on screen, even past the follow line", () => {
+ const scroll = scrollBox(0);
+ mount({ pps: 100, scroll });
+ act(() => liveTime.notifySeek(7));
+ expect(scroll.scrollLeft).toBe(0);
+ });
+
+ it("scrolls back to the playhead when a person seeks to the time it already has", () => {
+ const scroll = scrollBox(0);
+ mount({ pps: 100, scroll });
+ act(() => liveTime.notifySeek(30));
+ scroll.scrollLeft = 0;
+ act(() => liveTime.notifySeek(30));
+ expectVisible(scroll, 30, 100);
+ });
+
+ it("keeps a person's scroll when a reload republishes the seek rounded to a frame", () => {
+ const scroll = scrollBox(0);
+ mount({ pps: 100, scroll });
+ act(() => liveTime.notifySeek(12.3456));
+ scroll.scrollLeft = 0;
+ act(() => liveTime.notify(Math.floor(12.3456 * 30) / 30));
+ expect(scroll.scrollLeft).toBe(0);
+ });
+
+ it("keeps a person's scroll when a reload follows a keyboard pause", () => {
+ const scroll = scrollBox(0);
+ mount({ pps: 100, scroll });
+ act(() => usePlayerStore.setState({ isPlaying: true }));
+ act(() => liveTime.notify(30));
+ act(() => {
+ usePlayerStore.getState().setCurrentTime(30.012);
+ usePlayerStore.setState({ isPlaying: false });
+ });
+ scroll.scrollLeft = 0;
+ act(() => liveTime.notify(30.012));
+ expect(scroll.scrollLeft).toBe(0);
+ });
+
+ it("keeps a person's scroll when a reload stops a reverse shuttle", () => {
+ usePlayerStore.setState({ currentTime: 30 });
+ const scroll = scrollBox(0);
+ mount({ pps: 100, scroll });
+ act(() => usePlayerStore.setState({ isPlaying: true }));
+ act(() => liveTime.notify(29));
+ act(() => liveTime.notify(20));
+ act(() => usePlayerStore.setState({ isPlaying: false }));
+ scroll.scrollLeft = 0;
+ act(() => liveTime.notify(20));
+ expect(scroll.scrollLeft).toBe(0);
+ });
+
+ it("does not scroll while the playhead is being dragged", () => {
+ const scroll = scrollBox(0);
+ mount({ pps: 100, scroll, dragging: true });
+ act(() => liveTime.notifySeek(30));
+ expect(scroll.scrollLeft).toBe(0);
+ });
+
+ it("does not scroll while a beat is being dragged past the edge", () => {
+ usePlayerStore.setState({ beatDragging: true });
+ const scroll = scrollBox(0);
+ mount({ pps: 100, scroll });
+ act(() => liveTime.notifySeek(30));
+ expect(scroll.scrollLeft).toBe(0);
+ });
+
+ it("does not scroll in Fit", () => {
+ const scroll = scrollBox(0);
+ mount({ pps: 100, scroll, zoomMode: "fit" });
+ act(() => liveTime.notifySeek(30));
+ expect(scroll.scrollLeft).toBe(0);
});
});
diff --git a/packages/studio/src/player/components/useTimelinePlayhead.ts b/packages/studio/src/player/components/useTimelinePlayhead.ts
index 8f8bbdb087..1770400112 100644
--- a/packages/studio/src/player/components/useTimelinePlayhead.ts
+++ b/packages/studio/src/player/components/useTimelinePlayhead.ts
@@ -12,6 +12,22 @@ import {
import { getTimelinePlayheadTransform } from "./timelinePlayheadTransform";
import { applyTimelineHorizontalAutoScrollStep } from "./timelineEditing";
+function revealPlayheadScrollLeft(
+ scroll: HTMLDivElement,
+ playheadX: number,
+ contentOrigin: number,
+ from = scroll.scrollLeft,
+): number {
+ if (playheadX >= from + contentOrigin && playheadX <= from + scroll.clientWidth) return from;
+ return getTimelinePlaybackFollowScrollLeft({
+ playheadX,
+ currentScrollLeft: from,
+ viewportWidth: scroll.clientWidth,
+ contentOrigin,
+ maxScrollLeft: scroll.scrollWidth - scroll.clientWidth,
+ });
+}
+
interface UseTimelinePlayheadInput {
playheadRef: React.RefObject<HTMLDivElement | null>;
scrollRef: React.RefObject<HTMLDivElement | null>;
@@ -58,10 +74,13 @@ export function useTimelinePlayhead({
}: UseTimelinePlayheadInput) {
const dragScrollRaf = useRef(0);
const previousZoomModeRef = useRef<ZoomMode | null>(zoomMode);
- // Center-anchored magnify: keep the time at the viewport center fixed when
- // the zoom level (pps) changes via the toolbar / slider. The pinch handler
- // anchors at the cursor instead, so it opts out via `skipCenterAnchorRef`.
+ // A toolbar zoom keeps the playhead in place; a resize keeps the centre, or 00:00 at the start.
+ // The pinch handler anchors at the cursor instead, so it opts out via `skipCenterAnchorRef`.
const previousAnchorPpsRef = useRef(pps);
+ const userZoomCount = usePlayerStore((s) => s.userZoomCount);
+ const previousZoomCountRef = useRef(userZoomCount);
+ const lastLiveTimeRef = useRef(usePlayerStore.getState().currentTime);
+ const lastSeekCountRef = useRef(liveTime.seekCount());
const skipCenterAnchorRef = useRef(false);
const contentOriginRef = useRef(contentOrigin);
contentOriginRef.current = contentOrigin;
@@ -70,15 +89,22 @@ export function useTimelinePlayhead({
const scroll = scrollRef.current;
const prevPps = previousAnchorPpsRef.current;
previousAnchorPpsRef.current = pps;
+ const prevZoomCount = previousZoomCountRef.current;
+ previousZoomCountRef.current = userZoomCount;
// Always consume the skip flag, even when pps didn't change — otherwise a
// pinch that produced no pps change (already at the zoom clamp) would strand
// it true and the next toolbar zoom would wrongly skip center-anchoring.
const skip = skipCenterAnchorRef.current;
skipCenterAnchorRef.current = false;
- // A view at the start stays there: a resize or a host zoom must not hide 00:00.
- if (!scroll || pps === prevPps || skip || scroll.scrollLeft < 1) return;
+ if (!scroll || pps === prevPps || skip) return;
+ const zoomed = userZoomCount !== prevZoomCount;
+ if (!zoomed && scroll.scrollLeft < 1) return;
+ const time = Math.max(0, lastLiveTimeRef.current);
+ const playheadX = contentOrigin + time * prevPps;
+ const onScreen =
+ revealPlayheadScrollLeft(scroll, playheadX, contentOrigin) === scroll.scrollLeft;
const nextScrollLeft = getTimelineScrollLeftForZoomAnchor({
- pointerX: scroll.clientWidth / 2,
+ pointerX: zoomed && onScreen ? playheadX - scroll.scrollLeft : scroll.clientWidth / 2,
currentScrollLeft: scroll.scrollLeft,
contentOrigin,
currentPixelsPerSecond: prevPps,
@@ -86,8 +112,11 @@ export function useTimelinePlayhead({
duration: durationRef.current,
});
const maxScrollLeft = Math.max(0, scroll.scrollWidth - scroll.clientWidth);
- scroll.scrollLeft = Math.max(0, Math.min(maxScrollLeft, nextScrollLeft));
- }, [pps, scrollRef, durationRef, contentOrigin]);
+ const anchored = Math.max(0, Math.min(maxScrollLeft, nextScrollLeft));
+ scroll.scrollLeft = zoomed
+ ? revealPlayheadScrollLeft(scroll, contentOrigin + time * pps, contentOrigin, anchored)
+ : anchored;
+ }, [pps, userZoomCount, scrollRef, durationRef, contentOrigin]);
const syncPlayheadPosition = useCallback(
(time: number) => {
@@ -127,7 +156,6 @@ export function useTimelinePlayhead({
}, [zoomMode, scrollRef]);
useMountEffect(() => {
- let lastLiveTime = usePlayerStore.getState().currentTime;
const place = (t: number, atRest: boolean) => {
if (!playheadRef.current || durationRef.current <= 0) return false;
playheadRef.current.style.transform = getTimelinePlayheadTransform(
@@ -138,29 +166,30 @@ export function useTimelinePlayhead({
);
return true;
};
+ const dragging = () => isDragging.current || usePlayerStore.getState().beatDragging;
const unsubPlaying = usePlayerStore.subscribe((state, prev) => {
- if (prev.isPlaying && !state.isPlaying) place(lastLiveTime, true);
+ if (prev.isPlaying && !state.isPlaying) place(lastLiveTimeRef.current, true);
});
+ lastSeekCountRef.current = liveTime.seekCount();
const unsub = liveTime.subscribe((t) => {
- lastLiveTime = t;
- if (!place(t, !usePlayerStore.getState().isPlaying)) return;
+ const sought = liveTime.seekCount() !== lastSeekCountRef.current;
+ lastSeekCountRef.current = liveTime.seekCount();
+ lastLiveTimeRef.current = t;
+ const playing = usePlayerStore.getState().isPlaying;
+ if (!place(t, !playing)) return;
const playheadX = contentOriginRef.current + Math.max(0, t) * ppsRef.current;
const scroll = scrollRef.current;
- if (
- !scroll ||
- !usePlayerStore.getState().isPlaying ||
- isDragging.current ||
- zoomModeRef.current === "fit"
- ) {
- return;
- }
- const nextScrollLeft = getTimelinePlaybackFollowScrollLeft({
- playheadX,
- currentScrollLeft: scroll.scrollLeft,
- viewportWidth: scroll.clientWidth,
- contentOrigin: contentOriginRef.current,
- maxScrollLeft: scroll.scrollWidth - scroll.clientWidth,
- });
+ // Paused, only a seek scrolls: a reload's republish, frame-rounded, must not undo a person's scroll.
+ if (!scroll || dragging() || zoomModeRef.current === "fit" || (!playing && !sought)) return;
+ const nextScrollLeft = playing
+ ? getTimelinePlaybackFollowScrollLeft({
+ playheadX,
+ currentScrollLeft: scroll.scrollLeft,
+ viewportWidth: scroll.clientWidth,
+ contentOrigin: contentOriginRef.current,
+ maxScrollLeft: scroll.scrollWidth - scroll.clientWidth,
+ })
+ : revealPlayheadScrollLeft(scroll, playheadX, contentOriginRef.current);
if (Math.abs(nextScrollLeft - scroll.scrollLeft) >= 0.5) {
scroll.scrollLeft = nextScrollLeft;
}
diff --git a/packages/studio/src/player/components/useTimelineZoom.ts b/packages/studio/src/player/components/useTimelineZoom.ts
index f4b3e74399..f452e5af9f 100644
--- a/packages/studio/src/player/components/useTimelineZoom.ts
+++ b/packages/studio/src/player/components/useTimelineZoom.ts
@@ -1,4 +1,5 @@
// fallow-ignore-file dead-code
+import { useCallback } from "react";
import { usePlayerStore, type ZoomMode } from "../store/playerStore";
export interface TimelineZoomState {
@@ -13,6 +14,13 @@ export function useTimelineZoom(): TimelineZoomState {
const zoomMode = usePlayerStore((s) => s.zoomMode);
const manualZoomPercent = usePlayerStore((s) => s.manualZoomPercent);
const setZoomMode = usePlayerStore((s) => s.setZoomMode);
- const setManualZoomPercent = usePlayerStore((s) => s.setManualZoomPercent);
+ const setStorePercent = usePlayerStore((s) => s.setManualZoomPercent);
+ const setManualZoomPercent = useCallback(
+ (percent: number) => {
+ usePlayerStore.setState((s) => ({ userZoomCount: s.userZoomCount + 1 }));
+ setStorePercent(percent);
+ },
+ [setStorePercent],
+ );
return { zoomMode, manualZoomPercent, setZoomMode, setManualZoomPercent };
}
diff --git a/packages/studio/src/player/hooks/useTimelinePlayer.seek.test.ts b/packages/studio/src/player/hooks/useTimelinePlayer.seek.test.ts
index 5d0fa43899..473065bc31 100644
--- a/packages/studio/src/player/hooks/useTimelinePlayer.seek.test.ts
+++ b/packages/studio/src/player/hooks/useTimelinePlayer.seek.test.ts
@@ -6,6 +6,8 @@ import type { useTimelinePlayer } from "./useTimelinePlayer";
import {
attachIframeAdapter,
attachIframeWindow,
+ makeAdapterWindow,
+ makeFakeIframe,
renderTimelinePlayerHarness,
resetPlayerStore,
} from "./timelinePlayerTestHarness";
@@ -263,6 +265,48 @@ describe("useTimelinePlayer audio controls (#835)", () => {
});
describe("useTimelinePlayer seek keepPlaying option (#834)", () => {
+ it("publishes a seek as a person's seek, so a paused timeline follows it", () => {
+ const { root, api } = renderAttachedTimelinePlayer();
+ const before = liveTime.seekCount();
+ seekWithAct(api, 5);
+ expect(liveTime.seekCount()).toBe(before + 1);
+ expect(liveTime.latest()).toBe(5);
+ unmountWithAct(root);
+ });
+
+ it("does not count a reload's hand-over as a person's seek", () => {
+ const { getApi, root } = renderTimelinePlayerHarness();
+ act(() => {
+ getApi().iframeRef.current = makeFakeIframe(makeAdapterWindow().win);
+ getApi().onIframeLoad();
+ });
+ seekWithAct(getApi(), 7);
+ act(() => getApi().refreshPlayer());
+ const seeks = liveTime.seekCount();
+ const gen = getApi().previewSlots.find((s) => s.role === "shadow")!.gen;
+ const shadow = makeFakeIframe(makeAdapterWindow().win);
+ shadow.src = "http://localhost/api/projects/demo/preview?_t=1";
+ act(() => {
+ getApi().setShadowIframeNode(shadow);
+ getApi().onShadowIframeLoad(gen);
+ getApi().onShadowReadyChange(gen, true);
+ });
+ expect(getApi().iframeRef.current).toBe(shadow);
+ expect(liveTime.latest()).toBe(7);
+ expect(liveTime.seekCount()).toBe(seeks);
+ unmountWithAct(root);
+ });
+
+ it("does not count the audition's return to the paused time as a person's seek", () => {
+ const { api, root } = renderAttachedTimelinePlayer();
+ seekWithAct(api, 4);
+ const seeks = liveTime.seekCount();
+ act(() => usePlayerStore.getState().requestPlayback(false, 2));
+ expect(liveTime.latest()).toBe(2);
+ expect(liveTime.seekCount()).toBe(seeks);
+ unmountWithAct(root);
+ });
+
it("default seek() clears isPlaying when the store reports playing", () => {
const { api, root } = renderAttachedTimelinePlayer();
setStorePlaying();
diff --git a/packages/studio/src/player/hooks/useTimelinePlayer.ts b/packages/studio/src/player/hooks/useTimelinePlayer.ts
index 421ad84607..b470feae2e 100644
--- a/packages/studio/src/player/hooks/useTimelinePlayer.ts
+++ b/packages/studio/src/player/hooks/useTimelinePlayer.ts
@@ -47,6 +47,9 @@ export interface UseTimelinePlayerOptions {
onPreviewReloadFailed?: (message: string) => void;
}
+const publishSeek = (time: number, options?: { follow?: boolean }) =>
+ options?.follow === false ? liveTime.notify(time) : liveTime.notifySeek(time);
+
export function useTimelinePlayer({
onShadowPromoted,
onPreviewReloadFailed,
@@ -276,7 +279,7 @@ export function useTimelinePlayer({
stopRAFLoop();
}, [getAdapter, setCurrentTime, setIsPlaying, stopRAFLoop, stopReverseLoop]);
const seek = useCallback(
- (time: number, options?: { keepPlaying?: boolean }) => {
+ (time: number, options?: { keepPlaying?: boolean; follow?: boolean }) => {
const wasReverseShuttle = shuttleDirectionRef.current === "backward";
stopReverseLoop();
const adapter = getAdapter();
@@ -295,7 +298,7 @@ export function useTimelinePlayer({
nextTime,
});
adapter.seek(nextTime, options);
- liveTime.notify(nextTime); // Direct DOM updates (playhead, timecode, progress) — no re-render
+ publishSeek(nextTime, options); // Direct DOM updates (playhead, timecode, progress) — no re-render
setCurrentTime(nextTime); // sync store so Split/Delete have accurate time
if (!shouldResumeAfterSeek && !keepPlaying) scrubMusicAtSeek(iframeRef.current, nextTime);
if (shouldResumeAfterSeek) {
@@ -344,7 +347,7 @@ export function useTimelinePlayer({
if (request.playing) play();
else {
pause();
- if (request.returnTo !== null) seek(request.returnTo);
+ if (request.returnTo !== null) seek(request.returnTo, { follow: false });
}
usePlayerStore.getState().clearPlaybackRequest();
}
@@ -409,7 +412,7 @@ export function useTimelinePlayer({
onReloadFailed: onPreviewReloadFailed,
handOverPlayback: (time, playing) => {
// keepPlaying: move the playhead without the paused-seek audio scrub.
- seek(time, { keepPlaying: true });
+ seek(time, { keepPlaying: true, follow: false });
const adapter = getAdapter();
// An edit that cut the film short of the live time stops it at the new end, as playback does.
if (playing && adapter && adapter.getTime() < adapter.getDuration()) play();
diff --git a/packages/studio/src/player/store/liveTime.ts b/packages/studio/src/player/store/liveTime.ts
index ed2050efe9..087bf5cc48 100644
--- a/packages/studio/src/player/store/liveTime.ts
+++ b/packages/studio/src/player/store/liveTime.ts
@@ -2,12 +2,18 @@
type TimeListener = (time: number) => void;
const timeListeners = new Set<TimeListener>();
let latestTime = 0;
+let seekCount = 0;
export const liveTime = {
notify: (time: number) => {
latestTime = time;
timeListeners.forEach((listener) => listener(time));
},
+ notifySeek: (time: number) => {
+ seekCount += 1;
+ liveTime.notify(time);
+ },
+ seekCount: () => seekCount,
latest: () => latestTime,
subscribe: (listener: TimeListener) => {
timeListeners.add(listener);
diff --git a/packages/studio/src/player/store/playerStore.ts b/packages/studio/src/player/store/playerStore.ts
index f513f7b28d..5296c96f6b 100644
--- a/packages/studio/src/player/store/playerStore.ts
+++ b/packages/studio/src/player/store/playerStore.ts
@@ -83,6 +83,7 @@ interface PlayerState extends PlayerStoreSlices {
zoomMode: ZoomMode;
/** Timeline zoom percent relative to the fit width when in manual mode */
manualZoomPercent: number;
+ userZoomCount: number;
/**
* Bumped on every live z-index edit (handleDomZIndexReorderCommit apply AND
* rollback). Flashless z commits (skipReload) never reload the iframe or
@@ -279,6 +280,7 @@ export const usePlayerStore = create<PlayerState>((set, get) => ({
loopEnabled: false,
zoomMode: "fit",
manualZoomPercent: 100,
+ userZoomCount: 0,
zEditVersion: 0,
timelinePps: 100,
timelineFitPps: 100,