Open source Loom alternative. Beautiful, shareable screen recordings.
Rust appcapcossloommacnextjsnextjs15open-sourceossreactrecordrustscreen-capturescreen-recorderscreenshotsolidjstauritauri-apptypescriptvite
import {
createEventListener,
createEventListenerMap,
} from "@solid-primitives/event-listener";
import {
batch,
createEffect,
createMemo,
createRoot,
createSignal,
For,
Show,
} from "solid-js";
import { produce } from "solid-js/store";
import { useEditorContext } from "../context";
import { useTimelineContext, useTrackContext } from "./context";
import {
SegmentContent,
SegmentHandle,
SegmentLabel,
SegmentRoot,
TrackRoot,
useSetPreviewTime,
} from "./Track";
export type SceneSegmentDragState =
| { type: "idle" }
| { type: "movePending" }
| { type: "moving" };
const MIN_SCENE_SEGMENT_PIXEL_WIDTH = 80;
export function SceneTrack(props: {
onDragStateChanged: (v: SceneSegmentDragState) => void;
handleUpdatePlayhead: (e: MouseEvent) => void;
}) {
const {
project,
setProject,
projectHistory,
setEditorState,
editorState,
projectActions,
totalDuration,
} = useEditorContext();
const { duration, secsPerPixel } = useTimelineContext();
const setPreviewTime = useSetPreviewTime();
const selectedSceneIndices = createMemo(() => {
const selection = editorState.timeline.selection;
if (!selection || selection.type !== "scene") return null;
return new Set(selection.indices);
});
const [hoveringSegment, setHoveringSegment] = createSignal(false);
const [hoveredTime, setHoveredTime] = createSignal<number>();
const [maxAvailableDuration, setMaxAvailableDuration] =
createSignal<number>(3);
// When we delete a segment that's being hovered, the onMouseLeave never fires
// because the element gets removed from the DOM. This leaves hoveringSegment stuck
// as true, which blocks the onMouseMove from setting hoveredTime, preventing
// users from creating new segments. This effect ensures we reset the hover state
// when all segments are deleted.
createEffect(() => {
const segments = project.timeline?.sceneSegments;
if (!segments || segments.length === 0) {
setHoveringSegment(false);
}
});
const getSceneIcon = (mode: string | undefined) => {
switch (mode) {
case "cameraOnly":
return <IconLucideVideo class="size-3.5" />;
case "hideCamera":
return <IconLucideEyeOff class="size-3.5" />;
case "splitScreen":
return <IconLucideColumns2 class="size-3.5" />;
case "floating":
return <IconLucidePanelRight class="size-3.5" />;
default:
return <IconLucideMonitor class="size-3.5" />;
}
};
const getSceneLabel = (mode: string | undefined) => {
switch (mode) {
case "cameraOnly":
return "Camera Only";
case "hideCamera":
return "Hide Camera";
case "splitScreen":
return "Split Screen";
case "floating":
return "Floating";
default:
return "Default";
}
};
return (
<TrackRoot
onMouseEnter={() => setEditorState("timeline", "hoveredTrack", "scene")}
onMouseMove={(e) => {
if (hoveringSegment()) {
setHoveredTime(undefined);
return;
}
const bounds = e.currentTarget.getBoundingClientRect();
let time =
(e.clientX - bounds.left) * secsPerPixel() +
editorState.timeline.transform.position;
const segments = project.timeline?.sceneSegments || [];
const nextSegmentIndex = segments.findIndex((s) => time < s.start);
let maxDuration = 3; // Default duration
if (nextSegmentIndex !== -1) {
const nextSegment = segments[nextSegmentIndex];
const prevSegmentIndex = nextSegmentIndex - 1;
if (prevSegmentIndex >= 0) {
const prevSegment = segments[prevSegmentIndex];
const gapStart = prevSegment.end;
const gapEnd = nextSegment.start;
const availableSpace = gapEnd - gapStart;
if (availableSpace < 0.5) {
setHoveredTime(undefined);
return;
}
if (time < gapStart) {
time = gapStart;
}
maxDuration = Math.min(3, gapEnd - time);
} else {
// No previous segment, only next segment
maxDuration = Math.min(3, nextSegment.start - time);
}
if (nextSegment.start - time < 0.5) {
setHoveredTime(undefined);
return;
}
} else if (segments.length > 0) {
const lastSegment = segments[segments.length - 1];
if (time < lastSegment.end) {
time = lastSegment.end;
}
maxDuration = Math.min(3, duration() - time);
} else {
maxDuration = Math.min(3, duration() - time);
}
if (maxDuration < 0.5) {
setHoveredTime(undefined);
return;
}
setMaxAvailableDuration(maxDuration);
setHoveredTime(Math.min(time, duration() - maxDuration));
}}
onMouseLeave={() => {
setHoveredTime();
setMaxAvailableDuration(3);
setEditorState("timeline", "hoveredTrack", null);
}}
onMouseDown={(e) => {
createRoot((dispose) => {
createEventListener(e.currentTarget, "mouseup", (e) => {
dispose();
const time = hoveredTime();
const maxDuration = maxAvailableDuration();
if (time === undefined) return;
e.stopPropagation();
batch(() => {
setProject("timeline", "sceneSegments", (v) => v ?? []);
setProject(
"timeline",
"sceneSegments",
produce((sceneSegments) => {
sceneSegments ??= [];
let index = sceneSegments.length;
for (let i = sceneSegments.length - 1; i >= 0; i--) {
if (sceneSegments[i].start > time) {
index = i;
break;
}
}
sceneSegments.splice(index, 0, {
start: time,
end: time + maxDuration,
mode: "cameraOnly",
});
}),
);
});
});
});
}}
>
<For
each={project.timeline?.sceneSegments}
fallback={
<div class="cap-empty-lane pointer-events-none">
<span>Switch layouts between your screen and camera</span>
<span class="cap-empty-lane-action">· Add scene</span>
</div>
}
>
{(segment, i) => {
const { setTrackState } = useTrackContext();
const sceneSegments = () => project.timeline?.sceneSegments ?? [];
// Double-clicking a handle expands the segment as far as it can go
// in that direction (up to the neighbouring segment / timeline edge).
const fillStart = () => {
const segs = sceneSegments();
let minValue = 0;
for (let j = segs.length - 1; j >= 0; j--) {
const s = segs[j];
if (s && s.end <= segment.start) {
minValue = s.end;
break;
}
}
batch(() => {
setProject("timeline", "sceneSegments", i(), "start", minValue);
setProject(
"timeline",
"sceneSegments",
produce((s) => {
s?.sort((a, b) => a.start - b.start);
}),
);
});
setPreviewTime(minValue);
};
const fillEnd = () => {
const segs = sceneSegments();
let maxValue = totalDuration();
for (let j = 0; j < segs.length; j++) {
const s = segs[j];
if (s && s.start > segment.end) {
maxValue = s.start;
break;
}
}
batch(() => {
setProject("timeline", "sceneSegments", i(), "end", maxValue);
setProject(
"timeline",
"sceneSegments",
produce((s) => {
s?.sort((a, b) => a.start - b.start);
}),
);
});
setPreviewTime(maxValue);
};
function createMouseDownDrag<T>(
setup: () => T,
_update: (e: MouseEvent, v: T, initialMouseX: number) => void,
) {
return (downEvent: MouseEvent) => {
if (editorState.timeline.interactMode !== "seek") return;
downEvent.stopPropagation();
const initial = setup();
let moved = false;
let initialMouseX: null | number = null;
setTrackState("draggingSegment", true);
const resumeHistory = projectHistory.pause();
props.onDragStateChanged({ type: "movePending" });
function finish(e: MouseEvent) {
resumeHistory();
const currentIndex = i();
const selection = editorState.timeline.selection;
const isMac =
navigator.platform.toUpperCase().indexOf("MAC") >= 0;
const isMultiSelect = isMac ? e.metaKey : e.ctrlKey;
const isRangeSelect = e.shiftKey;
if (!moved) {
e.stopPropagation();
if (
isRangeSelect &&
selection &&
selection.type === "scene"
) {
// Range selection: select from last selected to current
const existingIndices = selection.indices;
const lastIndex =
existingIndices[existingIndices.length - 1];
const start = Math.min(lastIndex, currentIndex);
const end = Math.max(lastIndex, currentIndex);
const rangeIndices = Array.from(
{ length: end - start + 1 },
(_, idx) => start + idx,
);
setEditorState("timeline", "selection", {
type: "scene" as const,
indices: rangeIndices,
});
} else if (
isMultiSelect &&
selection &&
selection.type === "scene"
) {
// Multi-select: toggle current index
const existingIndices = selection.indices;
if (existingIndices.includes(currentIndex)) {
// Remove from selection
const newIndices = existingIndices.filter(
(idx) => idx !== currentIndex,
);
if (newIndices.length > 0) {
setEditorState("timeline", "selection", {
type: "scene" as const,
indices: newIndices,
});
} else {
setEditorState("timeline", "selection", null);
}
} else {
// Add to selection
setEditorState("timeline", "selection", {
type: "scene" as const,
indices: [...existingIndices, currentIndex],
});
}
} else {
// Normal single selection
setEditorState("timeline", "selection", {
type: "scene" as const,
indices: [currentIndex],
});
}
props.handleUpdatePlayhead(e);
} else {
setEditorState("timeline", "selection", {
type: "scene" as const,
indices: [currentIndex],
});
}
props.onDragStateChanged({ type: "idle" });
setTrackState("draggingSegment", false);
}
function update(event: MouseEvent) {
if (Math.abs(event.clientX - downEvent.clientX) > 2) {
if (!moved) {
moved = true;
initialMouseX = event.clientX;
props.onDragStateChanged({
type: "moving",
});
}
}
if (initialMouseX === null) return;
_update(event, initial, initialMouseX);
}
createRoot((dispose) => {
createEventListenerMap(window, {
mousemove: (e) => {
update(e);
},
mouseup: (e) => {
update(e);
finish(e);
dispose();
},
});
});
};
}
const isSelected = createMemo(() => {
const indices = selectedSceneIndices();
if (!indices) return false;
return indices.has(i());
});
return (
<SegmentRoot
segColor="var(--track-scene)"
class="group"
selected={isSelected()}
title={`Scene · ${getSceneLabel(segment.mode)}`}
segment={segment}
onMouseEnter={() => {
setHoveringSegment(true);
}}
onMouseLeave={() => {
setHoveringSegment(false);
}}
onMouseDown={(e) => {
e.stopPropagation();
if (editorState.timeline.interactMode === "split") {
const rect = e.currentTarget.getBoundingClientRect();
const fraction = (e.clientX - rect.left) / rect.width;
const splitTime = fraction * (segment.end - segment.start);
projectActions.splitSceneSegment(i(), splitTime);
}
}}
>
<SegmentHandle
position="start"
onDblClick={(e) => {
e.stopPropagation();
fillStart();
}}
onMouseDown={createMouseDownDrag(
() => {
const start = segment.start;
const minDuration = Math.max(
1,
secsPerPixel() * MIN_SCENE_SEGMENT_PIXEL_WIDTH,
);
let minValue = 0;
const maxValue = segment.end - minDuration;
for (let i = sceneSegments().length - 1; i >= 0; i--) {
const segment = sceneSegments()[i];
if (!segment) continue;
if (segment.end <= start) {
minValue = segment.end;
break;
}
}
return { start, minValue, maxValue };
},
(e, value, initialMouseX) => {
const newStart =
value.start +
(e.clientX - initialMouseX) * secsPerPixel();
const nextStart = Math.min(
value.maxValue,
Math.max(value.minValue, newStart),
);
setProject(
"timeline",
"sceneSegments",
i(),
"start",
nextStart,
);
setProject(
"timeline",
"sceneSegments",
produce((s) => {
if (s) {
s.sort((a, b) => a.start - b.start);
}
}),
);
setPreviewTime(nextStart);
},
)}
/>
<SegmentContent
class="flex items-center cursor-grab"
onMouseDown={createMouseDownDrag(
() => {
const original = { ...segment };
const prevSegment = sceneSegments()[i() - 1];
const nextSegment = sceneSegments()[i() + 1];
const minStart = prevSegment?.end ?? 0;
const maxEnd = nextSegment?.start ?? duration();
return {
original,
minStart,
maxEnd,
};
},
(e, value, initialMouseX) => {
const rawDelta =
(e.clientX - initialMouseX) * secsPerPixel();
const newStart = value.original.start + rawDelta;
const newEnd = value.original.end + rawDelta;
let delta = rawDelta;
if (newStart < value.minStart)
delta = value.minStart - value.original.start;
else if (newEnd > value.maxEnd)
delta = value.maxEnd - value.original.end;
setProject("timeline", "sceneSegments", i(), {
start: value.original.start + delta,
end: value.original.end + delta,
});
},
)}
>
<SegmentLabel
full={() => (
<div class="cap-seg-labels animate-in fade-in">
<span class="cap-seg-label">Scene</span>
<span class="cap-seg-sublabel truncate">
{getSceneLabel(segment.mode)}
</span>
</div>
)}
compact={() => (
<div class="cap-seg-labels">
<span class="cap-seg-label truncate">
{getSceneLabel(segment.mode)}
</span>
</div>
)}
glyph={() => (
<div class="cap-seg-label flex justify-center items-center">
{getSceneIcon(segment.mode)}
</div>
)}
/>
</SegmentContent>
<SegmentHandle
position="end"
onDblClick={(e) => {
e.stopPropagation();
fillEnd();
}}
onMouseDown={createMouseDownDrag(
() => {
const end = segment.end;
const minDuration = Math.max(
1,
secsPerPixel() * MIN_SCENE_SEGMENT_PIXEL_WIDTH,
);
const minValue = segment.start + minDuration;
let maxValue = duration();
for (let i = 0; i < sceneSegments().length; i++) {
const segment = sceneSegments()[i];
if (!segment) continue;
if (segment.start > end) {
maxValue = segment.start;
break;
}
}
return { end, minValue, maxValue };
},
(e, value, initialMouseX) => {
const newEnd =
value.end + (e.clientX - initialMouseX) * secsPerPixel();
const nextEnd = Math.min(
value.maxValue,
Math.max(value.minValue, newEnd),
);
setProject(
"timeline",
"sceneSegments",
i(),
"end",
nextEnd,
);
setProject(
"timeline",
"sceneSegments",
produce((s) => {
if (s) {
s.sort((a, b) => a.start - b.start);
}
}),
);
setPreviewTime(nextEnd);
},
)}
/>
</SegmentRoot>
);
}}
</For>
<Show
when={!useTrackContext().trackState.draggingSegment && hoveredTime()}
>
{(time) => (
<SegmentRoot
class="pointer-events-none"
ghost
segColor="var(--track-scene)"
segment={{
start: time(),
end: time() + maxAvailableDuration(),
}}
>
<SegmentContent class="group justify-center">
<p class="cap-seg-label">+</p>
</SegmentContent>
</SegmentRoot>
)}
</Show>
</TrackRoot>
);
}