Skip to content

AI media harness for planning, generating, and editing locally

TypeScript

Pan timeline by dragging empty track space

Bittibc3bb44d5d88
diff --git a/src/components/workspace/TimelineView.test.tsx b/src/components/workspace/TimelineView.test.tsx
index 3dbdc4b..34a98aa 100644
--- a/src/components/workspace/TimelineView.test.tsx
+++ b/src/components/workspace/TimelineView.test.tsx
@@ -815,6 +815,39 @@ describe("the transport and the playhead", () => {
});
describe("zoom and the wheel", () => {
+ it.each(["pointerup", "pointercancel", "lostpointercapture", "blur"])("pans empty track space without editing and stops on %s", (ending) => {
+ const { container, onChange } = render_(withClip(measuredVideo(projectWithMedia(), 40_000), {}));
+ const scroll = container.querySelector(".timeline-grid-scroll") as HTMLElement;
+ scroll.scrollLeft = 300;
+ scroll.scrollTop = 100;
+ fireEvent(container.querySelector(".track-lane")!, pointerEvent("pointerdown", 400, 200));
+ expect(scroll.classList.contains("timeline-grid-scroll--panning")).toBe(true);
+ fireEvent(window, pointerEvent("pointermove", 250, 150));
+ expect(scroll.scrollLeft).toBe(450);
+ expect(scroll.scrollTop).toBe(150);
+ expect(toolbarTime(container)).toBe("00:00:00:00");
+ expect(onChange).not.toHaveBeenCalled();
+ fireEvent(ending === "lostpointercapture" ? scroll : window, pointerEvent(ending, 250, 150));
+ expect(scroll.classList.contains("timeline-grid-scroll--panning")).toBe(false);
+ fireEvent(window, pointerEvent("pointermove", 100, 100));
+ expect(scroll.scrollLeft).toBe(450);
+ expect(scroll.scrollTop).toBe(150);
+ });
+
+ it("pans the space below tracks but leaves clip and track-header gestures alone", () => {
+ const { container } = timeline(withClip(measuredVideo(projectWithMedia(), 40_000), {}));
+ const scroll = container.querySelector(".timeline-grid-scroll") as HTMLElement;
+ for (const selector of [".timeline-clip", ".track-head", ".track-name"]) {
+ fireEvent(container.querySelector(selector)!, pointerEvent("pointerdown", 400));
+ expect(scroll.classList.contains("timeline-grid-scroll--panning")).toBe(false);
+ fireEvent(window, pointerEvent("pointerup", 400));
+ }
+ fireEvent(container.querySelector(".timeline-grid")!, pointerEvent("pointerdown", 400));
+ fireEvent(window, pointerEvent("pointermove", 300));
+ expect(scroll.scrollLeft).toBe(100);
+ fireEvent(window, pointerEvent("pointerup", 300));
+ });
+
/** jsdom lays nothing out: give the scroll area a width so the lanes can be
* sized in pixels. 1180px less the 180px header column is 1000px of lane. */
function withViewport(width: number, body: () => void) {
diff --git a/src/components/workspace/TimelineView.tsx b/src/components/workspace/TimelineView.tsx
index c728560..68bb5b7 100644
--- a/src/components/workspace/TimelineView.tsx
+++ b/src/components/workspace/TimelineView.tsx
@@ -300,6 +300,8 @@ export function TimelineView({ config, folderPath, generationCompletionTimes = {
head). A press alone moves it once; this is what makes the moves keep
coming. */
const [scrubbing, setScrubbing] = useState(false);
+ const [panning, setPanning] = useState(false);
+ const panRef = useRef<{ pointerId: number; x: number; y: number; left: number; top: number } | null>(null);
const menu = useContextMenu();
const tracks = config.timeline.tracks;
const selected = useMemo(() => tracks.flatMap((track) => track.clips).find((clip) => clip.id === selectedId), [tracks, selectedId]);
@@ -450,7 +452,7 @@ export function TimelineView({ config, folderPath, generationCompletionTimes = {
Premiere's "page scroll" does, so the playhead never runs off the edge. */
useEffect(() => {
const element = scrollRef.current;
- if (!playing || !element || !lanePx) return;
+ if (!playing || !element || !lanePx || panRef.current) return;
const x = (playhead / duration) * lanePx;
const visible = element.clientWidth - trackPane.size;
if (x < element.scrollLeft || x > element.scrollLeft + visible - 16) element.scrollLeft = Math.max(0, x - 32);
@@ -462,6 +464,50 @@ export function TimelineView({ config, folderPath, generationCompletionTimes = {
* progress goes on extending under the pointer. */
const dropSelection = () => window.getSelection?.()?.removeAllRanges();
+ const beginPan = (event: React.PointerEvent<HTMLDivElement>) => {
+ if (event.button !== 0 || panRef.current || dragging || scrubbing) return;
+ if (!(event.target instanceof Element) || !event.target.matches(".track-lane, .timeline-grid")) return;
+ event.preventDefault();
+ dropSelection();
+ const element = event.currentTarget;
+ panRef.current = { pointerId: event.pointerId, x: event.clientX, y: event.clientY, left: element.scrollLeft, top: element.scrollTop };
+ element.setPointerCapture?.(event.pointerId);
+ setPanning(true);
+ };
+ useEffect(() => {
+ if (!panning) return;
+ const element = scrollRef.current;
+ const onMove = (event: PointerEvent) => {
+ const pan = panRef.current;
+ if (!pan || !element || event.pointerId !== pan.pointerId) return;
+ event.preventDefault();
+ element.scrollLeft = pan.left + pan.x - event.clientX;
+ element.scrollTop = pan.top + pan.y - event.clientY;
+ };
+ const finish = () => {
+ const pan = panRef.current;
+ panRef.current = null;
+ if (pan && element?.hasPointerCapture?.(pan.pointerId)) element.releasePointerCapture(pan.pointerId);
+ setPanning(false);
+ };
+ const onUp = (event: PointerEvent) => { if (event.pointerId === panRef.current?.pointerId) finish(); };
+ window.addEventListener("pointermove", onMove, { passive: false });
+ window.addEventListener("pointerup", onUp);
+ window.addEventListener("pointercancel", onUp);
+ window.addEventListener("blur", finish);
+ element?.addEventListener("lostpointercapture", onUp);
+ return () => {
+ window.removeEventListener("pointermove", onMove);
+ window.removeEventListener("pointerup", onUp);
+ window.removeEventListener("pointercancel", onUp);
+ window.removeEventListener("blur", finish);
+ element?.removeEventListener("lostpointercapture", onUp);
+ const pan = panRef.current;
+ panRef.current = null;
+ if (pan && element?.hasPointerCapture?.(pan.pointerId)) element.releasePointerCapture(pan.pointerId);
+ };
+ }, [panning]);
+
/** Turn a pointer position on the ruler into a playhead position. A ruler
* nothing has laid out has no scale, so it is left alone rather than
* sending the playhead to NaN. */
@@ -1631,7 +1677,7 @@ export function TimelineView({ config, folderPath, generationCompletionTimes = {
</div>
</header>
<div className="timeline-body">
- <div className="timeline-grid-scroll" ref={scrollRef}>
+ <div className={`timeline-grid-scroll${panning ? " timeline-grid-scroll--panning" : ""}`} ref={scrollRef} onPointerDown={beginPan}>
<div
className="timeline-grid"
style={{
diff --git a/src/styles/timeline.css b/src/styles/timeline.css
index 701d620..a3f07a5 100644
--- a/src/styles/timeline.css
+++ b/src/styles/timeline.css
@@ -1212,7 +1212,11 @@ button.transport-time:hover { background: var(--fill-subtle-hover); }
overflow: auto;
}
+.timeline-grid-scroll--panning,
+.timeline-grid-scroll--panning * { cursor: grabbing !important; }
+
.timeline-grid {
+ touch-action: none;
--track-column: var(--pane-timeline-tracks);
position: relative;
display: grid;