Skip to content

🎥 Make videos programmatically with React

12.4 KB
Raw Blame
import {CanvasInternals} from '@remotion/sdk';
import React, {useContext, useEffect, useMemo, useRef, useState} from 'react';
import {Internals} from 'remotion';
import {StudioServerConnectionCtx} from '../helpers/client-id';
import {
	BLUE,
	TIMELINE_DROP_BLUE_ALPHA_12,
	TRANSPARENT,
} from '../helpers/colors';
import {createDragAwareDoubleClickTracker} from '../helpers/drag-aware-double-click';
import {isStudioInteractivityEnabled} from '../helpers/interactivity-enabled';
import {isMac} from '../helpers/is-mac';
import {EditorShowGuidesContext} from '../state/editor-guides';
import {EditorSnappingContext} from '../state/editor-snapping';
import {
	addEffectFromDrop,
	hasEffectDragType,
	isLutEffectDrop,
	LUT_EFFECT_DROP_TARGET_ATTR,
} from './effect-drag-and-drop';
import {
	forceSpecificCursor,
	stopForcingSpecificCursor,
} from './ForceSpecificCursor';
import {showNotification} from './Notifications/NotificationCenter';
import {
	clearSelectedOutlineDragOverrides,
	type SelectedOutlineKeyframedDragChange,
	type SelectedOutlineStaticDragChange,
} from './selected-outline-drag';
import type {SelectedOutline} from './selected-outline-geometry';
import {
	getSelectedOutlineSnapTargets,
	type SelectedOutlineSnapPoint,
} from './selected-outline-snap';
import type {
	SelectedOutlineDragTarget,
	SelectedOutlineLayoutTarget,
	SelectedOutlineTarget,
} from './selected-outline-types';
import {commitPendingInspectorFields} from './Timeline/focus-inspector-field';
import {getCurrentFrame} from './Timeline/imperative-state';
import {saveSequenceProps} from './Timeline/save-sequence-prop';
import {PREVENT_CLEAR_SELECTION_ON_POINTER_DOWN_ATTR} from './Timeline/should-clear-selection-on-pointer-down';
import type {
	TimelineSelection,
	TimelineSelectionInteraction,
} from './Timeline/TimelineSelection';
import {
	isTimelineSelectionModifierEvent,
	useCurrentTimelineSelectionStateAsRef,
} from './Timeline/TimelineSelection';

const {
	CanvasOutlinePolygon,
	getCanvasOutlineTranslateDragStates,
	handleCanvasOutlinePointerDown,
	startCanvasOutlineTranslateDrag,
} = CanvasInternals;

export const SELECTED_OUTLINE_KEY_ATTR =
	'data-remotion-studio-selected-outline-key';

const SelectedOutlinePolygonUnmemoized: React.FC<{
	readonly compositionHeight: number;
	readonly compositionWidth: number;
	readonly containsSelection: boolean;
	readonly directlySelected: boolean;
	readonly dragging: boolean;
	readonly getAllDragOutlines: () => readonly SelectedOutline[];
	readonly getAllDragTargets: () => readonly SelectedOutlineDragTarget[];
	readonly getLayoutTarget: () => SelectedOutlineLayoutTarget | undefined;
	readonly getTarget: () => SelectedOutlineTarget | undefined;
	readonly hasTarget: boolean;
	readonly hovered: boolean;
	readonly outline: SelectedOutline;
	readonly onDraggingChange: (dragging: boolean) => void;
	readonly onHoverChange: (key: string | null) => void;
	readonly onSnapPointsChange: (
		snapPoints: readonly SelectedOutlineSnapPoint[],
	) => void;
	readonly onSelect: (
		item: TimelineSelection,
		interaction: TimelineSelectionInteraction,
	) => void;
	readonly onDoubleClickTarget: (
		target: SelectedOutlineTarget,
		button: number,
		sequenceWasDragged: boolean,
	) => boolean;
	readonly scale: number;
	readonly showSelectedOutline: boolean;
	readonly translateWithCommandKey: boolean;
}> = ({
	compositionHeight,
	compositionWidth,
	containsSelection,
	directlySelected,
	dragging,
	getAllDragOutlines,
	getAllDragTargets,
	getLayoutTarget,
	getTarget,
	hasTarget,
	hovered,
	outline,
	onDraggingChange,
	onHoverChange,
	onSnapPointsChange,
	onSelect,
	onDoubleClickTarget,
	scale,
	showSelectedOutline,
	translateWithCommandKey,
}) => {
	const {previewServerState} = useContext(StudioServerConnectionCtx);
	const dragAwareDoubleClick = useMemo(
		() => createDragAwareDoubleClickTracker(),
		[],
	);
	const {canvasContent} = useContext(Internals.CompositionManager);
	const dragOverridesRef = useContext(
		Internals.VisualModeDragOverridesRefContext,
	);
	const {setPropStatuses, setDragOverrides, clearDragOverrides} = useContext(
		Internals.VisualModeSettersContext,
	);
	const {editorSnapping} = useContext(EditorSnappingContext);
	const {editorShowGuides, guidesList} = useContext(EditorShowGuidesContext);
	const polygonRef = useRef<SVGPolygonElement>(null);
	const currentSelection = useCurrentTimelineSelectionStateAsRef();
	const [effectDropHovered, setEffectDropHovered] = useState(false);
	useEffect(() => {
		if (!effectDropHovered) {
			return;
		}

		const clearEffectDropHover = () => setEffectDropHovered(false);
		document.addEventListener('drop', clearEffectDropHover, {capture: true});
		document.addEventListener('dragend', clearEffectDropHover, {capture: true});
		return () => {
			document.removeEventListener('drop', clearEffectDropHover, {
				capture: true,
			});
			document.removeEventListener('dragend', clearEffectDropHover, {
				capture: true,
			});
		};
	}, [effectDropHovered]);
	const visible = showSelectedOutline || hovered;
	const getEffectDropTarget = React.useCallback(() => {
		if (
			previewServerState.type !== 'connected' ||
			!isStudioInteractivityEnabled()
		) {
			return null;
		}

		const target = getLayoutTarget();
		if (target?.sequence.controls?.supportsEffects !== true) {
			return null;
		}

		const nodePath = target.nodePathInfo.sequenceSubscriptionKey;
		return {
			clientId: previewServerState.clientId,
			fileName: nodePath.absolutePath,
			nodePathInfo: target.nodePathInfo,
		};
	}, [getLayoutTarget, previewServerState]);

	const onPointerDown = React.useCallback(
		(event: React.PointerEvent<SVGPolygonElement>) => {
			const target = getTarget();
			const decision = handleCanvasOutlinePointerDown({
				event,
				polygon: polygonRef.current,
				hasTarget: target !== undefined,
				selected: target?.selected ?? false,
				containsSelection,
				translateWithCommandKey,
				isMac,
			});
			if (decision === null || target === undefined) {
				return;
			}

			const {drag} = target;
			const {
				interaction,
				temporaryTranslate,
				shouldUpdateSelection,
				deferSelection,
				dragExistingSelection,
			} = decision;
			if (!deferSelection && shouldUpdateSelection) {
				onSelect(target.selection, interaction);
			}

			if (
				interaction.shiftKey ||
				interaction.toggleKey ||
				(drag === null && !deferSelection)
			) {
				return;
			}

			if (commitPendingInspectorFields()) {
				if (deferSelection) {
					onSelect(target.selection, interaction);
				}

				return;
			}

			const dragTargets = dragExistingSelection
				? getAllDragTargets()
				: drag === null
					? []
					: [drag];
			if (dragTargets.length === 0) {
				if (deferSelection) {
					onSelect(target.selection, interaction);
				}

				return;
			}

			const [{clientId}] = dragTargets;
			startCanvasOutlineTranslateDrag({
				event,
				captureTarget: event.currentTarget,
				dragStates: getCanvasOutlineTranslateDragStates({
					dragTargets,
					getDragOverrides: dragOverridesRef.current.getDragOverrides,
					timelinePosition: getCurrentFrame(),
				}),
				scale,
				snapping: editorSnapping
					? {
							outlines: dragExistingSelection
								? getAllDragOutlines()
								: [outline],
							getTargets: () =>
								getSelectedOutlineSnapTargets({
									compositionHeight,
									compositionWidth,
									guides:
										editorShowGuides && canvasContent?.type === 'composition'
											? guidesList.filter(
													(guide) =>
														guide.compositionId === canvasContent.compositionId,
												)
											: [],
								}),
							onSnapPointsChange,
							// Command already means "translate" in rotation mode.
							modifierDisablesSnapping: !temporaryTranslate,
						}
					: null,
				setDragOverrides,
				clearDragOverrides,
				onDragStart: () => {
					onDraggingChange(true);
					forceSpecificCursor('default');
				},
				onDragEnd: ({changes, dragged, released, session}) => {
					dragAwareDoubleClick.endPointerGesture(dragged);
					if (dragged) {
						stopForcingSpecificCursor();
						onDraggingChange(false);
					}

					if (changes.length === 0) {
						if (deferSelection && !dragged && released) {
							onSelect(target.selection, interaction);
						}

						return;
					}

					const staticChanges = changes.filter(
						(change): change is SelectedOutlineStaticDragChange =>
							change.type === 'static',
					);
					const keyframedChanges = changes.filter(
						(change): change is SelectedOutlineKeyframedDragChange =>
							change.type === 'keyframed',
					);

					saveSequenceProps({
						changes: staticChanges,
						addedKeyframes: keyframedChanges,
						movedKeyframes: null,
						setPropStatuses,
						clientId,
						undoLabel:
							changes.length > 1 ? 'Move selected sequences' : 'Move sequence',
						redoLabel:
							changes.length > 1
								? 'Move selected sequences back'
								: 'Move sequence back',
					})
						.catch((err) => {
							showNotification(
								`Could not save sequence props: ${
									err instanceof Error ? err.message : String(err)
								}`,
								4000,
							);
						})
						.finally(() => {
							clearSelectedOutlineDragOverrides({
								clearDragOverrides,
								dragStates: session.dragStates,
							});
						});
				},
			});
		},
		[
			canvasContent,
			clearDragOverrides,
			compositionHeight,
			compositionWidth,
			containsSelection,
			dragAwareDoubleClick,
			editorShowGuides,
			editorSnapping,
			getAllDragOutlines,
			getAllDragTargets,
			dragOverridesRef,
			getTarget,
			guidesList,
			onDraggingChange,
			onSelect,
			onSnapPointsChange,
			outline,
			scale,
			setPropStatuses,
			setDragOverrides,
			translateWithCommandKey,
		],
	);

	const performDoubleClick = React.useCallback(
		(event: React.MouseEvent<SVGPolygonElement>) => {
			if (isTimelineSelectionModifierEvent(event)) {
				return;
			}

			const target = getTarget();
			if (target === undefined) {
				return;
			}

			if (
				!onDoubleClickTarget(
					target,
					event.button,
					dragAwareDoubleClick.consumePointerGestureWasDragged(),
				)
			) {
				return;
			}

			event.preventDefault();
			event.stopPropagation();
		},
		[dragAwareDoubleClick, getTarget, onDoubleClickTarget],
	);
	const onClick = React.useCallback(
		(event: React.MouseEvent<SVGPolygonElement>) => {
			if (!dragAwareDoubleClick.acceptClickAsDoubleClick(event)) {
				return;
			}

			performDoubleClick(event);
		},
		[dragAwareDoubleClick, performDoubleClick],
	);

	const onEffectDragOver = React.useCallback(
		(event: React.DragEvent<SVGPolygonElement>) => {
			if (!hasEffectDragType(event.dataTransfer)) {
				return;
			}

			const effectDrop = getEffectDropTarget();
			if (effectDrop === null) {
				return;
			}

			event.preventDefault();
			event.stopPropagation();
			event.dataTransfer.dropEffect = 'copy';
			setEffectDropHovered(true);
		},
		[getEffectDropTarget],
	);

	const onEffectDragLeave = React.useCallback(
		(event: React.DragEvent<SVGPolygonElement>) => {
			if (event.currentTarget.contains(event.relatedTarget as Node | null)) {
				return;
			}

			setEffectDropHovered(false);
		},
		[],
	);

	const onEffectDrop = React.useCallback(
		async (event: React.DragEvent<SVGPolygonElement>) => {
			if (
				!hasEffectDragType(event.dataTransfer) &&
				!isLutEffectDrop(event.nativeEvent)
			) {
				return;
			}

			const effectDrop = getEffectDropTarget();
			if (effectDrop === null) {
				return;
			}

			event.preventDefault();
			event.stopPropagation();
			setEffectDropHovered(false);

			await addEffectFromDrop({
				dataTransfer: event.dataTransfer,
				fileName: effectDrop.fileName,
				nodePathInfo: effectDrop.nodePathInfo,
				clientId: effectDrop.clientId,
				selectItems: currentSelection.current.selectItems,
			});
		},
		[currentSelection, getEffectDropTarget],
	);

	return (
		<CanvasOutlinePolygon
			ref={polygonRef}
			{...{
				[PREVENT_CLEAR_SELECTION_ON_POINTER_DOWN_ATTR]: 'true',
				[SELECTED_OUTLINE_KEY_ATTR]: outline.key,
				[LUT_EFFECT_DROP_TARGET_ATTR]:
					getEffectDropTarget() !== null ? 'true' : undefined,
			}}
			outline={outline}
			directlySelected={directlySelected}
			dragging={dragging}
			fill={effectDropHovered ? TIMELINE_DROP_BLUE_ALPHA_12 : TRANSPARENT}
			stroke={BLUE}
			visible={visible || effectDropHovered}
			interactive={hasTarget}
			onHoverChange={onHoverChange}
			onPointerDown={onPointerDown}
			onPointerDownCapture={dragAwareDoubleClick.beginPointerGesture}
			onClick={onClick}
			onDragOver={onEffectDragOver}
			onDragLeave={onEffectDragLeave}
			onDrop={onEffectDrop}
		/>
	);
};

export const SelectedOutlinePolygon = React.memo(
	SelectedOutlinePolygonUnmemoized,
);