🎥 Make videos programmatically with React
import type React from 'react';
import {memo, useContext, useEffect} from 'react';
import {Internals} from 'remotion';
import {useTimelineCalculator} from '../../helpers/calculate-timeline';
import {StudioServerConnectionCtx} from '../../helpers/client-id';
import {useKeybinding} from '../../helpers/use-keybinding';
import {useConfirmationDialog} from '../ConfirmationDialog';
import {OverrideIdToNodePathMappingsRefContext} from '../SequencePropsSubscriptionProvider';
import {duplicateSelectedTimelineItems} from './duplicate-selected-timeline-item';
import {getCurrentFrame} from './imperative-state';
import {splitSelectedTimelineItems} from './split-selected-timeline-item';
import {
useCurrentTimelineSelectionStateAsRef,
useTimelineSelectionCanSelect,
} from './TimelineSelection';
import {useDeleteTimelineItems} from './use-delete-timeline-items';
const TimelineDeleteKeybindingsUnmemoized: React.FC = () => {
const keybindings = useKeybinding();
const {previewServerState} = useContext(StudioServerConnectionCtx);
const calculateTimeline = useTimelineCalculator();
const sequencesRef = useContext(Internals.SequenceManagerRefContext);
const overrideIdToNodePathMappingsRef = useContext(
OverrideIdToNodePathMappingsRefContext,
);
const propStatusesRef = useContext(
Internals.VisualModePropStatusesRefContext,
);
const canSelect = useTimelineSelectionCanSelect();
const currentSelection = useCurrentTimelineSelectionStateAsRef();
const confirm = useConfirmationDialog();
const deleteTimelineItems = useDeleteTimelineItems();
useEffect(() => {
if (!canSelect || previewServerState.type !== 'connected') {
return;
}
const deleteKey = keybindings.registerKeybinding({
event: 'keydown',
action: 'deleteSelection',
callback: () => deleteTimelineItems(null),
preventDefault: true,
triggerIfInputFieldFocused: false,
keepRegisteredWhenNotHighestContext: false,
});
const duplicate = keybindings.registerKeybinding({
event: 'keydown',
action: 'duplicateSequences',
callback: () => {
const {selectedItems} = currentSelection.current;
if (selectedItems.length === 0) {
return;
}
const duplicatePromise = duplicateSelectedTimelineItems({
selections: selectedItems,
confirm,
});
if (duplicatePromise === null) {
return;
}
duplicatePromise.catch(() => undefined);
},
preventDefault: true,
triggerIfInputFieldFocused: false,
keepRegisteredWhenNotHighestContext: false,
});
const split = keybindings.registerKeybinding({
event: 'keydown',
action: 'splitSequences',
callback: () => {
const {selectedItems} = currentSelection.current;
if (selectedItems.length === 0) {
return;
}
const splitPromise = splitSelectedTimelineItems({
selections: selectedItems,
tracks: calculateTimeline({
sequences: sequencesRef.current,
overrideIdsToNodePaths: overrideIdToNodePathMappingsRef.current,
}).tracks,
propStatuses: propStatusesRef.current,
splitFrame: getCurrentFrame(),
});
if (splitPromise === null) {
return;
}
splitPromise.catch(() => undefined);
},
preventDefault: true,
triggerIfInputFieldFocused: false,
keepRegisteredWhenNotHighestContext: false,
});
return () => {
deleteKey.unregister();
duplicate.unregister();
split.unregister();
};
}, [
canSelect,
confirm,
currentSelection,
deleteTimelineItems,
keybindings,
calculateTimeline,
overrideIdToNodePathMappingsRef,
propStatusesRef,
previewServerState,
sequencesRef,
]);
return null;
};
export const TimelineDeleteKeybindings = memo(
TimelineDeleteKeybindingsUnmemoized,
);