Skip to content

🎥 Make videos programmatically with React

10.2 KB
Raw Blame
import React, {useCallback, useContext, useMemo} from 'react';
import {Internals, type CanUpdateSequencePropStatus} from 'remotion';
import {StudioServerConnectionCtx} from '../../helpers/client-id';
import type {TimelineTrackData} from '../../helpers/get-timeline-sequence-sort-key';
import {isStudioInteractivityEnabled} from '../../helpers/interactivity-enabled';
import {AlignBottomIcon} from '../../icons/align-bottom';
import {AlignCenterHorizontalIcon} from '../../icons/align-center-horizontal';
import {AlignCenterVerticalIcon} from '../../icons/align-center-vertical';
import {AlignLeftIcon} from '../../icons/align-left';
import {AlignRightIcon} from '../../icons/align-right';
import {AlignTopIcon} from '../../icons/align-top';
import {ActionTooltip} from '../ActionTooltip';
import {InlineAction} from '../InlineAction';
import {INSPECTOR_PANEL_HORIZONTAL_PADDING} from '../InspectorPanelLayout';
import {showNotification} from '../Notifications/NotificationCenter';
import {getSelectedOutlineActiveSchema} from '../selected-outline-drag';
import {translateFieldKey} from '../selected-outline-types';
import {callAddSequenceKeyframe} from '../Timeline/call-add-keyframe';
import {
	getKeyframeDisplayOffset,
	getKeyframeSourceFrame,
} from '../Timeline/get-timeline-keyframes';
import {
	getCurrentDimensions,
	getCurrentFrame,
} from '../Timeline/imperative-state';
import {saveSequenceProps} from '../Timeline/save-sequence-prop';
import {
	parseTranslate,
	serializeTranslate,
} from '../Timeline/timeline-translate-utils';
import {computeAlignedTranslate} from './alignment-controls';

const isPropStatusDraggable = (
	propStatus: CanUpdateSequencePropStatus | undefined,
) => {
	return (
		!propStatus ||
		propStatus.status === 'static' ||
		(propStatus.status === 'keyframed' &&
			propStatus.interpolationFunction === 'interpolate')
	);
};

const container: React.CSSProperties = {
	display: 'flex',
	flexDirection: 'row',
	gap: 4,
	padding: `0 ${INSPECTOR_PANEL_HORIZONTAL_PADDING}px 12px`,
	alignItems: 'center',
};

const iconStyle: React.CSSProperties = {
	width: 16,
	height: 16,
};

const verticalSpacer: React.CSSProperties = {
	width: 1,
	height: 16,
	margin: '0 8px',
};

const AlignmentButton: React.FC<{
	readonly onClick: () => void;
	readonly 'aria-label': string;
	readonly Icon: React.FC<React.SVGProps<SVGSVGElement>>;
	readonly disabled: boolean;
}> = ({onClick, 'aria-label': ariaLabel, Icon, disabled}) => {
	return (
		<ActionTooltip label={ariaLabel} shortcut={null} delay={800} dismissOnClick>
			<InlineAction
				variant={null}
				aria-label={ariaLabel}
				onClick={onClick}
				renderAction={(color) => <Icon style={iconStyle} color={color} />}
				disabled={disabled}
			/>
		</ActionTooltip>
	);
};

const AlignmentControlsUnmemoized: React.FC<{
	readonly track: TimelineTrackData;
}> = ({track}) => {
	const {previewServerState} = useContext(StudioServerConnectionCtx);
	const {propStatuses} = useContext(Internals.VisualModePropStatusesContext);
	const propStatusesRef = useContext(
		Internals.VisualModePropStatusesRefContext,
	);
	const {getDragOverrides} = useContext(
		Internals.VisualModeDragOverridesContext,
	);
	const {setPropStatuses} = useContext(Internals.VisualModeSettersContext);
	const {canvasContent, compositions} = useContext(
		Internals.CompositionManager,
	);
	const currentCompositionMetadata = useMemo(() => {
		if (canvasContent?.type !== 'composition') return null;
		return (
			compositions.find((c) => c.id === canvasContent.compositionId) ?? null
		);
	}, [canvasContent, compositions]);

	const handleAlign = useCallback(
		(
			direction: 'left' | 'center-h' | 'right' | 'top' | 'center-v' | 'bottom',
		) => {
			if (
				!isStudioInteractivityEnabled() ||
				previewServerState.type !== 'connected' ||
				!track.nodePathInfo ||
				!track.sequence.controls
			) {
				showNotification('Alignment is unavailable for this sequence.', 1000);
				return;
			}

			const timelinePosition = getCurrentFrame();
			const runtimeValues = track.sequence.controls.runtimeValues.getSnapshot();
			const nodePath = track.nodePathInfo.sequenceSubscriptionKey;
			const nodePropStatuses = Internals.getPropStatusesCtx(
				propStatusesRef.current,
				nodePath,
			);
			const dragOverrides = getDragOverrides(nodePath) ?? {};

			const activeSchema = getSelectedOutlineActiveSchema({
				schema: track.sequence.controls.schema,
				currentRuntimeValueDotNotation: runtimeValues,
				dragOverrides,
				propStatus: nodePropStatuses,
				frame:
					(timelinePosition - track.keyframeDisplayOffset) *
					track.keyframePlaybackRate,
			});

			const fieldSchema = activeSchema?.[translateFieldKey];
			const propStatus = nodePropStatuses?.[translateFieldKey];

			if (fieldSchema?.type !== 'translate') {
				showNotification(
					'This sequence does not support alignment at the current frame.',
					1000,
				);
				return;
			}

			if (!isPropStatusDraggable(propStatus)) {
				showNotification(
					'Cannot align this sequence because its translate property is not editable.',
					1000,
				);
				return;
			}

			const ref = track.sequence.refForOutline?.current;
			if (!ref) {
				showNotification(
					'This sequence is not available in the preview for alignment.',
					1000,
				);
				return;
			}

			let elementRect: DOMRect;
			try {
				elementRect = ref.getBoundingClientRect();
			} catch {
				showNotification(
					'Could not measure this sequence for alignment.',
					1000,
				);
				return;
			}

			const {width} = getCurrentDimensions();
			if (!width) {
				showNotification(
					'Composition dimensions are unavailable for alignment.',
					1000,
				);
				return;
			}

			const compositionRect = Internals.portalNode().getBoundingClientRect();
			if (compositionRect.width === 0 || compositionRect.height === 0) {
				showNotification(
					'The composition preview is not ready for alignment.',
					1000,
				);
				return;
			}

			const scale = compositionRect.width / width;

			const currentTranslate = propStatus
				? String(
						Internals.getEffectiveVisualModeValue({
							// eslint-disable-next-line @typescript-eslint/no-explicit-any
							propStatus: propStatus as any,
							dragOverrideValue: dragOverrides[translateFieldKey],
							defaultValue: fieldSchema.default,
							frame:
								(timelinePosition - track.keyframeDisplayOffset) *
								track.keyframePlaybackRate,
							shouldResortToDefaultValueIfUndefined: true,
						}) ??
							fieldSchema.default ??
							'0px 0px',
					)
				: String(fieldSchema.default ?? '0px 0px');

			const [currentX, currentY, currentZ] = parseTranslate(currentTranslate);

			const {x: newX, y: newY} = computeAlignedTranslate({
				direction,
				elementRect,
				compositionRect,
				currentTranslateX: currentX,
				currentTranslateY: currentY,
				scale,
			});

			const newValue = serializeTranslate([newX, newY, currentZ]);

			const undoLabels = {
				left: 'Align left',
				'center-h': 'Align center horizontally',
				right: 'Align right',
				top: 'Align top',
				'center-v': 'Align center vertically',
				bottom: 'Align bottom',
			};

			const label = undoLabels[direction];

			if (!propStatus || propStatus.status === 'static') {
				saveSequenceProps({
					addedKeyframes: null,
					movedKeyframes: null,
					changes: [
						{
							fileName: nodePath.absolutePath,
							nodePath,
							fieldKey: translateFieldKey,
							value: newValue,
							defaultValue:
								fieldSchema.default !== undefined
									? JSON.stringify(fieldSchema.default)
									: null,
							schema: track.sequence.controls.schema,
						},
					],
					setPropStatuses,
					clientId: previewServerState.clientId,
					undoLabel: label,
					redoLabel: label,
				});
			} else {
				callAddSequenceKeyframe({
					fileName: nodePath.absolutePath,
					nodePath,
					fieldKey: translateFieldKey,
					sourceFrame: getKeyframeSourceFrame({
						displayFrame: timelinePosition,
						keyframeDisplayOffset: getKeyframeDisplayOffset({
							propStatus,
							keyframeDisplayOffset: track.keyframeDisplayOffset,
							keyframePlaybackRate: track.keyframePlaybackRate,
						}),
						keyframePlaybackRate: track.keyframePlaybackRate,
						propStatus,
					}),
					value: newValue,
					schema: track.sequence.controls.schema,
					setPropStatuses,
					clientId: previewServerState.clientId,
				});
			}
		},
		[
			previewServerState,
			track,
			propStatusesRef,
			getDragOverrides,
			setPropStatuses,
		],
	);

	if (
		!isStudioInteractivityEnabled() ||
		previewServerState.type !== 'connected' ||
		!track.nodePathInfo ||
		!track.sequence.controls ||
		!currentCompositionMetadata
	) {
		return null;
	}

	const {schema} = track.sequence.controls;
	// Enum variants may change eligibility with the frame. Keep the action
	// available in that case and resolve the active schema when clicked.
	const hasSchemaVariants = Object.values(schema).some(
		(field) => field.type === 'enum',
	);
	if (!hasSchemaVariants && schema[translateFieldKey]?.type !== 'translate') {
		return null;
	}

	const renderNodePropStatuses = Internals.getPropStatusesCtx(
		propStatuses,
		track.nodePathInfo.sequenceSubscriptionKey,
	);
	const alignmentDisabled =
		!hasSchemaVariants &&
		!isPropStatusDraggable(renderNodePropStatuses?.[translateFieldKey]);

	return (
		<div style={container}>
			<AlignmentButton
				aria-label="Align left"
				onClick={() => handleAlign('left')}
				Icon={AlignLeftIcon}
				disabled={alignmentDisabled}
			/>
			<AlignmentButton
				aria-label="Align center horizontally"
				onClick={() => handleAlign('center-h')}
				Icon={AlignCenterHorizontalIcon}
				disabled={alignmentDisabled}
			/>
			<AlignmentButton
				aria-label="Align right"
				onClick={() => handleAlign('right')}
				Icon={AlignRightIcon}
				disabled={alignmentDisabled}
			/>
			<div style={verticalSpacer} />
			<AlignmentButton
				aria-label="Align top"
				onClick={() => handleAlign('top')}
				Icon={AlignTopIcon}
				disabled={alignmentDisabled}
			/>
			<AlignmentButton
				aria-label="Align center vertically"
				onClick={() => handleAlign('center-v')}
				Icon={AlignCenterVerticalIcon}
				disabled={alignmentDisabled}
			/>
			<AlignmentButton
				aria-label="Align bottom"
				onClick={() => handleAlign('bottom')}
				Icon={AlignBottomIcon}
				disabled={alignmentDisabled}
			/>
		</div>
	);
};

export const AlignmentControls = React.memo(AlignmentControlsUnmemoized);