Skip to content

🎥 Make videos programmatically with React

7.0 KB
Raw Blame
import React, {useCallback, useContext, useMemo} from 'react';
import {TIMELINE_TRACK_SEPARATOR} from '../../helpers/colors';
import {createDragAwareDoubleClickTracker} from '../../helpers/drag-aware-double-click';
import {Padder} from './Padder';
import {
	getTimelineRowIndentWidth,
	getTimelineRowLeftChromeWidth,
} from './timeline-row-layout';
import {TimelineRowLayoutContext} from './TimelineRowLayoutContext';
import type {TimelineSelectionInteraction} from './TimelineSelection';
import {
	getTimelineRowHighlightBackground,
	isTimelineSelectionModifierEvent,
	TIMELINE_SELECTED_BACKGROUND,
} from './TimelineSelection';

export const TimelineRowSelectedBackgroundContext = React.createContext<string>(
	TIMELINE_SELECTED_BACKGROUND,
);

const rowBase: React.CSSProperties = {
	alignItems: 'stretch',
	display: 'flex',
};

const leftChromeStyle: React.CSSProperties = {
	alignItems: 'center',
	alignSelf: 'stretch',
	display: 'flex',
	flexShrink: 0,
};

const keyframeControlsColumnBaseStyle: React.CSSProperties = {
	alignItems: 'center',
	display: 'flex',
	flexShrink: 0,
	justifyContent: 'flex-start',
};

export const TimelineRowKeyframeControlsColumn: React.FC<{
	readonly children: React.ReactNode;
	readonly depth: number;
}> = ({children, depth}) => {
	const {basePadding, keyframeControlsPadding} = useContext(
		TimelineRowLayoutContext,
	);
	const style = useMemo(
		(): React.CSSProperties => ({
			...keyframeControlsColumnBaseStyle,
			boxSizing: keyframeControlsPadding === 0 ? undefined : 'border-box',
			paddingLeft: keyframeControlsPadding,
			width: getTimelineRowLeftChromeWidth(depth, basePadding),
		}),
		[basePadding, depth, keyframeControlsPadding],
	);

	return (
		<div style={leftChromeStyle}>
			<div style={style}>{children}</div>
		</div>
	);
};

export const TimelineRowChrome: React.FC<{
	readonly depth: number;
	readonly eye: React.ReactNode;
	readonly keyframeControls?: React.ReactNode;
	readonly arrow: React.ReactNode;
	readonly children: React.ReactNode;
	readonly style: React.CSSProperties;
	readonly selected: boolean;
	readonly selectable: boolean;
	readonly onSelect: (interaction?: TimelineSelectionInteraction) => void;
	readonly showSelectedBackground: boolean;
	readonly containsSelection: boolean;
	readonly hovered?: boolean;
	// When set, the chrome is wrapped in an outer container of this height with a
	// bottom track separator. The background highlight and click target span the
	// outer (used by sequence rows whose layer is taller than the chrome row).
	readonly outerHeight: number | null;
	readonly showBottomBorder: boolean;
	readonly onDragLeave?: (e: React.DragEvent<HTMLDivElement>) => void;
	readonly onDragOver?: (e: React.DragEvent<HTMLDivElement>) => void;
	readonly onDrop?: (e: React.DragEvent<HTMLDivElement>) => void;
	readonly onDoubleClick?: (e: React.MouseEvent<HTMLDivElement>) => void;
	readonly onPointerEnter?: () => void;
	readonly onPointerLeave?: () => void;
}> = ({
	depth,
	eye,
	keyframeControls,
	arrow,
	children,
	style,
	selected,
	selectable,
	onSelect,
	showSelectedBackground,
	containsSelection,
	hovered = false,
	outerHeight,
	showBottomBorder,
	onDragLeave,
	onDragOver,
	onDrop,
	onDoubleClick,
	onPointerEnter,
	onPointerLeave,
}) => {
	const {basePadding, rowBorderRadius, rowHorizontalMargin} = useContext(
		TimelineRowLayoutContext,
	);
	const selectedBackground = useContext(TimelineRowSelectedBackgroundContext);
	const doubleClickTracker = useMemo(
		() => createDragAwareDoubleClickTracker(),
		[],
	);
	const indentWidth = getTimelineRowIndentWidth(depth);

	const chromeColumnStyle = useMemo(
		(): React.CSSProperties => ({
			alignItems: 'center',
			alignSelf: 'stretch',
			display: 'flex',
			flexShrink: 0,
			paddingLeft: basePadding,
		}),
		[basePadding],
	);

	const onPointerDown = useCallback(
		(e: React.PointerEvent<HTMLDivElement>) => {
			if (e.button === 0) {
				e.stopPropagation();
				if (isTimelineSelectionModifierEvent(e)) {
					onSelect({
						shiftKey: e.shiftKey,
						toggleKey: e.metaKey || e.ctrlKey,
					});
				}
			}
		},
		[onSelect],
	);

	const onContextMenu = useCallback(
		(e: React.MouseEvent<HTMLDivElement>) => {
			e.stopPropagation();
			if (!selected) {
				onSelect();
			}
		},
		[onSelect, selected],
	);

	const onClick = useCallback(
		(e: React.MouseEvent<HTMLDivElement>) => {
			const {target} = e;
			if (
				target instanceof Element &&
				e.currentTarget.contains(
					target.closest(
						'button, input, select, textarea, a, [contenteditable="true"]',
					),
				)
			) {
				e.stopPropagation();
				return;
			}

			if (
				selectable &&
				e.button === 0 &&
				!isTimelineSelectionModifierEvent(e)
			) {
				onSelect();
			}

			if (!doubleClickTracker.acceptClickAsDoubleClick(e)) {
				return;
			}

			onDoubleClick?.(e);
		},
		[doubleClickTracker, onDoubleClick, onSelect, selectable],
	);

	const highlightBackground = getTimelineRowHighlightBackground({
		showSelectedBackground,
		selected,
		containsSelection,
		hovered,
		selectedBackground,
	});

	const innerRowStyle = useMemo(
		(): React.CSSProperties => ({
			...rowBase,
			...style,
			backgroundColor: outerHeight === null ? highlightBackground : undefined,
			borderRadius: rowBorderRadius,
			margin: `0 ${rowHorizontalMargin}px`,
		}),
		[
			style,
			outerHeight,
			highlightBackground,
			rowBorderRadius,
			rowHorizontalMargin,
		],
	);

	const outerStyle = useMemo((): React.CSSProperties | undefined => {
		if (outerHeight === null) {
			return undefined;
		}

		return {
			height: outerHeight,
			borderBottom: `1px solid ${showBottomBorder ? TIMELINE_TRACK_SEPARATOR : 'transparent'}`,
			display: 'flex',
			flexDirection: 'column',
			justifyContent: 'center',
			backgroundColor: highlightBackground,
		};
	}, [outerHeight, highlightBackground, showBottomBorder]);

	const chrome = (
		<>
			{keyframeControls ? (
				<TimelineRowKeyframeControlsColumn depth={depth}>
					{keyframeControls}
				</TimelineRowKeyframeControlsColumn>
			) : (
				<div style={leftChromeStyle}>
					<div style={chromeColumnStyle}>
						{eye}
						{indentWidth > 0 ? <Padder depth={depth} /> : null}
						{arrow}
					</div>
				</div>
			)}
			{children}
		</>
	);

	if (outerStyle) {
		return (
			<div
				style={outerStyle}
				onDragLeave={onDragLeave}
				onDragOver={onDragOver}
				onDrop={onDrop}
				onPointerDownCapture={doubleClickTracker.beginPointerGesture}
				onPointerDown={selectable ? onPointerDown : undefined}
				onClick={onClick}
				onContextMenu={selectable ? onContextMenu : undefined}
				onPointerEnter={onPointerEnter}
				onPointerLeave={onPointerLeave}
			>
				<div style={innerRowStyle}>{chrome}</div>
			</div>
		);
	}

	return (
		<div
			onDragLeave={onDragLeave}
			onDragOver={onDragOver}
			onDrop={onDrop}
			onPointerDownCapture={doubleClickTracker.beginPointerGesture}
			onPointerDown={selectable ? onPointerDown : undefined}
			onClick={onClick}
			onContextMenu={selectable ? onContextMenu : undefined}
			onPointerEnter={onPointerEnter}
			onPointerLeave={onPointerLeave}
			style={innerRowStyle}
		>
			{chrome}
		</div>
	);
};