Skip to content

armgit / Cap

Public Imported from GitHub
0

Open source Loom alternative. Beautiful, shareable screen recordings.

16.9 KB
Raw Blame
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>
	);
}