Skip to content

🎥 Make videos programmatically with React

6.6 KB
Raw Blame
import type {RenderJob} from '@remotion/studio-shared';
import React, {
	useCallback,
	useContext,
	useEffect,
	useMemo,
	useState,
} from 'react';
import type {CanvasContent} from 'remotion';
import {Internals} from 'remotion';
import {getBrowserStudioOperations} from '../../helpers/browser-studio-operations';
import {getBackgroundFromHoverState} from '../../helpers/colors';
import {pushUrl} from '../../helpers/url-state';
import {Row, Spacing} from '../layout';
import type {ClientRenderJob} from './client-side-render-types';
import {isRestoredClientJob} from './client-side-render-types';
import type {AnyRenderJob} from './context';
import {isClientRenderJob} from './context';
import {RENDER_QUEUE_ITEM_SELECTED_CLASSNAME} from './item-style';
import {RenderQueueCancelledMessage} from './RenderQueueCancelledMessage';
import {
	RenderQueueCopyToClipboard,
	supportsCopyingToClipboard,
} from './RenderQueueCopyToClipboard';
import {RenderQueueDownloadItem} from './RenderQueueDownloadItem';
import {RenderQueueError} from './RenderQueueError';
import {RenderQueueCancelButton} from './RenderQueueItemCancelButton';
import {RenderQueueItemStatus} from './RenderQueueItemStatus';
import {RenderQueueOpenInFinderItem} from './RenderQueueOpenInFolder';
import {RenderQueueOutputName} from './RenderQueueOutputName';
import {RenderQueueProgressMessage} from './RenderQueueProgressMessage';
import {RenderQueueRemoveItem} from './RenderQueueRemoveItem';
import {RenderQueueRepeatItem} from './RenderQueueRepeat';
import {RenderQueueSavingMessage} from './RenderQueueSavingMessage';
import {useRenderOutputFileDrag} from './use-render-output-file-drag';

const container: React.CSSProperties = {
	padding: 12,
	display: 'flex',
	flexDirection: 'row',
	paddingBottom: 10,
	paddingRight: 4,
	marginBottom: 1,
	marginLeft: 4,
	borderRadius: 4,
	width: 'calc(100% - 4px)',
};

const title: React.CSSProperties = {
	fontSize: 13,
	lineHeight: 1,
};

const right: React.CSSProperties = {
	flex: 1,
	display: 'flex',
	flexDirection: 'column',
	overflow: 'hidden',
};

const subtitle: React.CSSProperties = {
	maxWidth: '100%',
	flex: 1,
	display: 'flex',
	overflow: 'hidden',
};

export const RenderQueueItem: React.FC<{
	readonly job: AnyRenderJob;
	readonly selected: boolean;
}> = ({job, selected}) => {
	const [hovered, setHovered] = useState(false);

	const {setCanvasContent} = useContext(Internals.CompositionSetters);

	const isClientJob = isClientRenderJob(job);
	const isBrowserStudio = getBrowserStudioOperations() !== null;
	const {canDrag, isDragging, onDragEnd, onDragStart} =
		useRenderOutputFileDrag(job);

	const onPointerEnter = useCallback(() => {
		setHovered(true);
	}, []);

	const onPointerLeave = useCallback(() => {
		setHovered(false);
	}, []);

	const isHoverable =
		job.status === 'done' && (isClientJob || job.type !== 'sequence');

	const containerStyle: React.CSSProperties = useMemo(() => {
		return {
			...container,
			backgroundColor: getBackgroundFromHoverState({
				hovered: isHoverable && hovered,
				selected,
			}),
			userSelect: 'none',
			WebkitUserSelect: 'none',
		};
	}, [hovered, isHoverable, selected]);

	const scrollCurrentIntoView = useCallback(() => {
		document
			.querySelector(`.${RENDER_QUEUE_ITEM_SELECTED_CLASSNAME}`)
			?.scrollIntoView({behavior: 'smooth'});
	}, []);

	const clientBlobInfo = useMemo(() => {
		if (!isClientJob || job.status !== 'done' || !job.getBlob) {
			return null;
		}

		return {
			getBlob: job.getBlob,
			width: job.metadata.width,
			height: job.metadata.height,
			sizeInBytes: job.metadata.sizeInBytes,
		};
	}, [isClientJob, job]);

	const onClick: React.MouseEventHandler = useCallback(() => {
		if (job.status !== 'done') {
			return;
		}

		// Cannot show folders
		if (!isClientJob && job.type === 'sequence') {
			return;
		}

		if (clientBlobInfo) {
			setCanvasContent((c: CanvasContent | null): CanvasContent => {
				const isAlreadySelected =
					c && c.type === 'output-blob' && c.displayName === job.outName;

				if (isAlreadySelected && !selected) {
					scrollCurrentIntoView();
					return c;
				}

				return {
					type: 'output-blob',
					displayName: job.outName,
					getBlob: clientBlobInfo.getBlob,
					width: clientBlobInfo.width,
					height: clientBlobInfo.height,
					sizeInBytes: clientBlobInfo.sizeInBytes,
				};
			});
			return;
		}

		setCanvasContent((c: CanvasContent | null): CanvasContent => {
			const isAlreadySelected =
				c && c.type === 'output' && c.path === `/${job.outName}`;

			if (isAlreadySelected && !selected) {
				scrollCurrentIntoView();
				return c;
			}

			return {type: 'output', path: `/${job.outName}`};
		});
		pushUrl(`/outputs/${job.outName}`);
	}, [
		job,
		isClientJob,
		clientBlobInfo,
		scrollCurrentIntoView,
		selected,
		setCanvasContent,
	]);

	useEffect(() => {
		if (selected) {
			scrollCurrentIntoView();
		}
	}, [scrollCurrentIntoView, selected]);

	const canCopyToClipboard =
		job.status === 'done' &&
		!isClientJob &&
		supportsCopyingToClipboard(job as RenderJob);

	const canRepeat =
		(job.status === 'done' ||
			job.status === 'failed' ||
			job.status === 'cancelled') &&
		!(isClientRenderJob(job) && isRestoredClientJob(job));

	return (
		<Row
			data-render-queue-item={job.id}
			onPointerEnter={onPointerEnter}
			onPointerLeave={onPointerLeave}
			style={containerStyle}
			align="center"
			onClick={onClick}
			draggable={canDrag}
			onDragStart={onDragStart}
			onDragEnd={onDragEnd}
			className={selected ? RENDER_QUEUE_ITEM_SELECTED_CLASSNAME : undefined}
		>
			<RenderQueueItemStatus job={job} />
			<Spacing x={1} />
			<div style={right}>
				<div style={title}>{job.compositionId}</div>
				<div style={subtitle}>
					{job.status === 'done' ? (
						<RenderQueueOutputName job={job} />
					) : job.status === 'failed' ? (
						<RenderQueueError job={job} />
					) : job.status === 'running' ? (
						<RenderQueueProgressMessage job={job} />
					) : job.status === 'saving' ? (
						<RenderQueueSavingMessage />
					) : job.status === 'cancelled' ? (
						<RenderQueueCancelledMessage />
					) : null}
				</div>
			</div>
			<Spacing x={1} />
			{!isDragging ? (
				<>
					{canCopyToClipboard ? (
						<RenderQueueCopyToClipboard job={job as RenderJob} />
					) : null}
					{canRepeat ? <RenderQueueRepeatItem job={job} /> : null}
					{job.status === 'running' ? (
						<RenderQueueCancelButton job={job} />
					) : isBrowserStudio ? null : (
						<RenderQueueRemoveItem job={job} />
					)}
					{job.status === 'done' ? (
						clientBlobInfo ? (
							<RenderQueueDownloadItem job={job as ClientRenderJob} />
						) : isBrowserStudio ? null : (
							<RenderQueueOpenInFinderItem job={job} />
						)
					) : null}
				</>
			) : null}
		</Row>
	);
};