Skip to content

🎥 Make videos programmatically with React

Add rolling and source-only timeline trims

Jonny Burgerc3dc5afb30ed
diff --git a/packages/studio/src/components/Timeline/Timeline.tsx b/packages/studio/src/components/Timeline/Timeline.tsx
index 008ba5fad1..c6bfdec4b7 100644
--- a/packages/studio/src/components/Timeline/Timeline.tsx
+++ b/packages/studio/src/components/Timeline/Timeline.tsx
@@ -61,6 +61,7 @@ import {
TimelineSelectAllKeybindings,
useCurrentTimelineSelectionStateAsRef,
} from './TimelineSelection';
+import {TimelineRippleEditHighlightProvider} from './TimelineSequence';
import {TimelineSequenceMediaDurationDragLimitsProvider} from './TimelineSequenceRightEdgeDragHandle';
import {TimelineSlider} from './TimelineSlider';
import {TimelineTickFormatProvider} from './TimelineTickFormatProvider';
@@ -544,9 +545,11 @@ const MemoizedTimelineInner = React.memo(TimelineInner);
export const Timeline: React.FC = () => {
return (
<TimelineTickFormatProvider>
- <TimelineSequenceMediaDurationDragLimitsProvider>
- <MemoizedTimelineInner />
- </TimelineSequenceMediaDurationDragLimitsProvider>
+ <TimelineRippleEditHighlightProvider>
+ <TimelineSequenceMediaDurationDragLimitsProvider>
+ <MemoizedTimelineInner />
+ </TimelineSequenceMediaDurationDragLimitsProvider>
+ </TimelineRippleEditHighlightProvider>
</TimelineTickFormatProvider>
);
};
diff --git a/packages/studio/src/components/Timeline/TimelineSequence.tsx b/packages/studio/src/components/Timeline/TimelineSequence.tsx
index 8d94623303..25a3a95898 100644
--- a/packages/studio/src/components/Timeline/TimelineSequence.tsx
+++ b/packages/studio/src/components/Timeline/TimelineSequence.tsx
@@ -60,8 +60,7 @@ import {LoopedTimelineIndicator} from './LoopedTimelineIndicators';
import {splitSelectedTimelineItems} from './split-selected-timeline-item';
import {getTimelineAssetLinkInfo} from './timeline-asset-link';
import {timelineLeftEdgeCursor} from './timeline-left-edge-cursor';
-import {timelineRightEdgeCursor} from './timeline-right-edge-cursor';
-import {timelineRippleEdgeCursor} from './timeline-ripple-edge-cursor';
+import {timelineTrimEdgeCursor} from './timeline-trim-edge-cursor';
import {TimelineImageInfo} from './TimelineImageInfo';
import {
getTimelineSequenceSelectionKey,
@@ -93,10 +92,39 @@ import {useDeleteTimelineItems} from './use-delete-timeline-items';
import {useOpenSequenceInApps} from './use-open-sequence-in-apps';
import {getSequenceFreezeFrameMenuItem} from './use-sequence-freeze-frame-menu-item';
-const {getTimelineVisibleDuration, getTimelineVisibleStart} = CanvasInternals;
+const {
+ getTimelineVisibleDuration,
+ getTimelineVisibleStart,
+ sortItemsByCommitOrder,
+} = CanvasInternals;
const NEGATIVE_START_BORDER_WIDTH = 1;
const EDGE_DRAG_HIGHLIGHT_WIDTH = 12;
+type RippleEditHighlight = {
+ readonly sequenceId: TSequence['id'];
+ readonly edge: 'left' | 'right';
+};
+
+const TimelineRippleEditHighlightContext = React.createContext<{
+ readonly highlight: RippleEditHighlight | null;
+ readonly setHighlight: React.Dispatch<
+ React.SetStateAction<RippleEditHighlight | null>
+ >;
+} | null>(null);
+
+export const TimelineRippleEditHighlightProvider: React.FC<{
+ readonly children: React.ReactNode;
+}> = ({children}) => {
+ const [highlight, setHighlight] = useState<RippleEditHighlight | null>(null);
+ const value = useMemo(() => ({highlight, setHighlight}), [highlight]);
+
+ return (
+ <TimelineRippleEditHighlightContext.Provider value={value}>
+ {children}
+ </TimelineRippleEditHighlightContext.Provider>
+ );
+};
+
const TimelineSequenceFn: React.FC<{
readonly s: TimelineTrackData['sequence'];
readonly connectedCompositions: readonly _InternalTypes['AnyComposition'][];
@@ -485,6 +513,7 @@ const TimelineSequenceInner: React.FC<{
const mediaDurationDragLimitsRegistry = useContext(
TimelineSequenceMediaDurationDragLimitsContext,
);
+ const rippleEditHighlight = useContext(TimelineRippleEditHighlightContext);
const dragAwareDoubleClick = useMemo(
() => createDragAwareDoubleClickTracker(),
[],
@@ -492,14 +521,61 @@ const TimelineSequenceInner: React.FC<{
const [activeTrimEdge, setActiveTrimEdge] = useState<'left' | 'right' | null>(
null,
);
- const startLeftEdgeDrag = useCallback(() => setActiveTrimEdge('left'), []);
- const startRightEdgeDrag = useCallback(() => setActiveTrimEdge('right'), []);
+ const startEdgeDrag = useCallback(
+ (edge: 'left' | 'right', trimBeforeOnly: boolean) => {
+ setActiveTrimEdge(edge);
+ if (
+ trimBeforeOnly ||
+ s.controls?.componentIdentity !==
+ 'dev.remotion.remotion.Series.Sequence'
+ ) {
+ rippleEditHighlight?.setHighlight(null);
+ return;
+ }
+
+ const siblings = sortItemsByCommitOrder(
+ sequences.filter(
+ (candidate) =>
+ candidate.parent === s.parent &&
+ candidate.controls?.componentIdentity ===
+ 'dev.remotion.remotion.Series.Sequence',
+ ),
+ (candidate) => candidate.timelineOrder,
+ );
+ const index = siblings.findIndex((candidate) => candidate.id === s.id);
+ const adjacent = siblings[index + (edge === 'left' ? -1 : 1)];
+ rippleEditHighlight?.setHighlight(
+ adjacent
+ ? {
+ sequenceId: adjacent.id,
+ edge: edge === 'left' ? 'right' : 'left',
+ }
+ : null,
+ );
+ },
+ [
+ rippleEditHighlight,
+ s.controls?.componentIdentity,
+ s.id,
+ s.parent,
+ sequences,
+ ],
+ );
+ const startLeftEdgeDrag = useCallback(
+ (trimBeforeOnly: boolean) => startEdgeDrag('left', trimBeforeOnly),
+ [startEdgeDrag],
+ );
+ const startRightEdgeDrag = useCallback(
+ () => startEdgeDrag('right', false),
+ [startEdgeDrag],
+ );
const endEdgeDrag = useCallback(
(wasDragged: boolean) => {
setActiveTrimEdge(null);
+ rippleEditHighlight?.setHighlight(null);
dragAwareDoubleClick.endPointerGesture(wasDragged);
},
- [dragAwareDoubleClick],
+ [dragAwareDoubleClick, rippleEditHighlight],
);
const mediaMetadata = useMediaMetadata(
@@ -1119,6 +1195,12 @@ const TimelineSequenceInner: React.FC<{
(isCascadingSequence(s) || fromCanUpdate) &&
durationCanUpdate &&
trimBeforeCanUpdate;
+ const showTrimBeforeDragHandle =
+ isMedia &&
+ isTimelineSequenceLeftEdgeDraggable(s) &&
+ nodePath !== null &&
+ validatedLocation !== null &&
+ trimBeforeCanUpdate;
if ((maxMediaDuration === null && !s.loopDisplay) || visibleLayout === null) {
return null;
@@ -1136,7 +1218,12 @@ const TimelineSequenceInner: React.FC<{
const sequence = (
<TimelineSequenceCurrentFrame
s={s}
- activeTrimEdge={activeTrimEdge}
+ activeTrimEdge={
+ activeTrimEdge ??
+ (rippleEditHighlight?.highlight?.sequenceId === s.id
+ ? rippleEditHighlight.highlight.edge
+ : null)
+ }
displayDurationInFrames={displayDurationInFrames}
premount={visibleLayout.premount}
postmount={visibleLayout.postmount}
@@ -1153,13 +1240,16 @@ const TimelineSequenceInner: React.FC<{
onClick={canHandleSequenceDoubleClick ? onSequenceClick : null}
edgeDragHandles={
<>
- {showLeftEdgeDragHandle &&
+ {(showLeftEdgeDragHandle || showTrimBeforeDragHandle) &&
visibleLayout.leftEdgeVisible &&
negativeStartWidth === 0 &&
nodePathInfo &&
validatedLocation ? (
<TimelineSequenceLeftEdgeDragHandle
- cursor={`${timelineLeftEdgeCursor}, e-resize`}
+ cursor={`${timelineTrimEdgeCursor}, ew-resize`}
+ trimBeforeCursor={`${timelineLeftEdgeCursor}, e-resize`}
+ edgeEnabled={showLeftEdgeDragHandle}
+ trimBeforeEnabled={showTrimBeforeDragHandle}
nodePathInfo={nodePathInfo}
windowWidth={windowWidth}
timelineDurationInFrames={video.durationInFrames ?? 1}
@@ -1176,11 +1266,7 @@ const TimelineSequenceInner: React.FC<{
nodePathInfo &&
validatedLocation ? (
<TimelineSequenceRightEdgeDragHandle
- cursor={
- isCascadingSequence(s)
- ? `${timelineRippleEdgeCursor}, ew-resize`
- : `${timelineRightEdgeCursor}, w-resize`
- }
+ cursor={`${timelineTrimEdgeCursor}, ew-resize`}
nodePathInfo={nodePathInfo}
mediaDurationDragLimits={mediaDurationDragLimits}
windowWidth={windowWidth}
diff --git a/packages/studio/src/components/Timeline/TimelineSequenceRightEdgeDragHandle.tsx b/packages/studio/src/components/Timeline/TimelineSequenceRightEdgeDragHandle.tsx
index c0284fe301..646f7cf10e 100644
--- a/packages/studio/src/components/Timeline/TimelineSequenceRightEdgeDragHandle.tsx
+++ b/packages/studio/src/components/Timeline/TimelineSequenceRightEdgeDragHandle.tsx
@@ -213,6 +213,14 @@ export type TimelineSequenceLeftEdgeDragTarget = {
readonly nodePath: SequencePropsSubscriptionKey;
readonly playbackRate: number;
readonly positionField: 'from' | null;
+ readonly rollingPrevious: {
+ readonly fileName: string;
+ readonly initialDuration: number;
+ readonly minimumDuration: number;
+ readonly nodePath: SequencePropsSubscriptionKey;
+ readonly playbackRate: number;
+ readonly schema: InteractivitySchema;
+ } | null;
readonly schema: InteractivitySchema;
};
@@ -466,14 +474,19 @@ export const getTimelineSequenceLeftEdgeDragDelta = ({
deltaFrames,
playbackRate,
minimumDuration = 1,
+ minimumDeltaFrames = -Infinity,
}: {
readonly initialDuration: number;
readonly initialTrimBefore: number;
readonly deltaFrames: number;
readonly playbackRate: number;
readonly minimumDuration?: number;
+ readonly minimumDeltaFrames?: number;
}) => {
- const minDeltaFrames = 0 - initialTrimBefore / playbackRate;
+ const minDeltaFrames = Math.max(
+ minimumDeltaFrames,
+ -initialTrimBefore / playbackRate,
+ );
const maxDeltaFrames = initialDuration - minimumDuration;
return Math.max(minDeltaFrames, Math.min(deltaFrames, maxDeltaFrames));
@@ -486,6 +499,8 @@ export const getTimelineSequenceLeftEdgeDragValues = ({
deltaFrames,
playbackRate,
minimumDuration = 1,
+ minimumDeltaFrames = -Infinity,
+ trimBeforeOnly = false,
}: {
readonly initialDuration: number;
readonly initialFrom: number;
@@ -493,18 +508,25 @@ export const getTimelineSequenceLeftEdgeDragValues = ({
readonly deltaFrames: number;
readonly playbackRate: number;
readonly minimumDuration?: number;
+ readonly minimumDeltaFrames?: number;
+ readonly trimBeforeOnly?: boolean;
}) => {
- const clampedDeltaFrames = getTimelineSequenceLeftEdgeDragDelta({
- initialDuration,
- initialTrimBefore,
- deltaFrames,
- playbackRate,
- minimumDuration,
- });
+ const clampedDeltaFrames = trimBeforeOnly
+ ? Math.max(-initialTrimBefore / playbackRate, -deltaFrames)
+ : getTimelineSequenceLeftEdgeDragDelta({
+ initialDuration,
+ initialTrimBefore,
+ deltaFrames,
+ playbackRate,
+ minimumDuration,
+ minimumDeltaFrames,
+ });
return {
- durationInFrames: initialDuration - clampedDeltaFrames,
- from: initialFrom + clampedDeltaFrames,
+ durationInFrames: trimBeforeOnly
+ ? initialDuration
+ : initialDuration - clampedDeltaFrames,
+ from: trimBeforeOnly ? initialFrom : initialFrom + clampedDeltaFrames,
// Division and multiplication by playbackRate may not cancel exactly.
trimBefore:
clampedDeltaFrames === -initialTrimBefore / playbackRate
@@ -516,9 +538,11 @@ export const getTimelineSequenceLeftEdgeDragValues = ({
export const getTimelineSequenceLeftEdgeDragChanges = ({
targets,
deltaFrames,
+ trimBeforeOnly = false,
}: {
readonly targets: readonly TimelineSequenceLeftEdgeDragTarget[];
readonly deltaFrames: number;
+ readonly trimBeforeOnly?: boolean;
}): SaveSequencePropChange[] => {
return targets.flatMap((target) => {
const nextValues = getTimelineSequenceLeftEdgeDragValues({
@@ -528,8 +552,29 @@ export const getTimelineSequenceLeftEdgeDragChanges = ({
deltaFrames: deltaFrames * target.parentPlaybackRate,
playbackRate: target.playbackRate,
minimumDuration: target.minimumDuration,
+ minimumDeltaFrames: target.rollingPrevious
+ ? target.rollingPrevious.minimumDuration -
+ target.rollingPrevious.initialDuration
+ : -Infinity,
+ trimBeforeOnly,
});
const changes: SaveSequencePropChange[] = [];
+ if (target.rollingPrevious && !trimBeforeOnly) {
+ const previous = target.rollingPrevious;
+ const nextDuration =
+ previous.initialDuration +
+ (target.initialDuration - nextValues.durationInFrames);
+ if (nextDuration !== previous.initialDuration) {
+ changes.push({
+ fileName: previous.fileName,
+ nodePath: previous.nodePath,
+ fieldKey: 'durationInFrames',
+ value: nextDuration * previous.playbackRate,
+ defaultValue: null,
+ schema: previous.schema,
+ });
+ }
+ }
if (
target.positionField !== null &&
@@ -925,12 +970,14 @@ export const getTimelineSequenceLeftEdgeDragTargets = ({
sequences,
overrideIdsToNodePaths,
propStatuses,
+ trimBeforeOnly = false,
}: {
readonly draggedNodePathInfo: SequenceNodePathInfo;
readonly selectedItems: readonly TimelineSelection[];
readonly sequences: TSequence[];
readonly overrideIdsToNodePaths: OverrideIdToNodePaths;
readonly propStatuses: PropStatuses;
+ readonly trimBeforeOnly?: boolean;
}): TimelineSequenceLeftEdgeDragTarget[] | null => {
const draggedSelectionKey =
getTimelineSequenceSelectionKey(draggedNodePathInfo);
@@ -975,10 +1022,17 @@ export const getTimelineSequenceLeftEdgeDragTargets = ({
const nodePath = track.nodePathInfo.sequenceSubscriptionKey;
const trimsMedia =
originalSequence.type === 'audio' || originalSequence.type === 'video';
+ if (trimBeforeOnly && !trimsMedia) {
+ return null;
+ }
+
const positionField = isCascadingSequence(originalSequence) ? null : 'from';
if (
- (positionField === 'from' && !canUpdateFrom({propStatuses, nodePath})) ||
- !canUpdateDurationInFrames({propStatuses, nodePath}) ||
+ (!trimBeforeOnly &&
+ positionField === 'from' &&
+ !canUpdateFrom({propStatuses, nodePath})) ||
+ (!trimBeforeOnly &&
+ !canUpdateDurationInFrames({propStatuses, nodePath})) ||
!canUpdateTrimBefore({propStatuses, nodePath})
) {
return null;
@@ -992,11 +1046,78 @@ export const getTimelineSequenceLeftEdgeDragTargets = ({
const key = stringifySequenceSubscriptionKey(nodePath);
if (!targets.has(key)) {
const runtimeValues = controls.runtimeValues.getSnapshot();
+ const trimBeforeStatus = Internals.getPropStatusesCtx(
+ propStatuses,
+ nodePath,
+ )?.trimBefore;
+ const ownTrimBefore =
+ trimBeforeStatus?.status === 'static' &&
+ typeof trimBeforeStatus.codeValue === 'number'
+ ? trimBeforeStatus.codeValue
+ : typeof runtimeValues.trimBefore === 'number'
+ ? runtimeValues.trimBefore
+ : 0;
const playbackRate = getTrimPlaybackRate({
sequence: originalSequence,
runtimeValues,
});
const runtimeDuration = runtimeValues.durationInFrames;
+ let rollingPrevious: TimelineSequenceLeftEdgeDragTarget['rollingPrevious'] =
+ null;
+ if (
+ !trimBeforeOnly &&
+ targetNodePathInfos.length === 1 &&
+ isSeriesSequence(originalSequence)
+ ) {
+ const siblings = sortItemsByCommitOrder(
+ sequences.filter(
+ (candidate) =>
+ candidate.parent === originalSequence.parent &&
+ isSeriesSequence(candidate),
+ ),
+ (candidate) => candidate.timelineOrder,
+ );
+ const previous =
+ siblings[
+ siblings.findIndex(
+ (candidate) => candidate.id === originalSequence.id,
+ ) - 1
+ ];
+ if (previous) {
+ const previousControls = previous.controls;
+ const previousNodePath = previousControls?.overrideId
+ ? overrideIdsToNodePaths[previousControls.overrideId]
+ : undefined;
+ if (
+ !previousControls ||
+ !previousNodePath ||
+ !canUpdateDurationInFrames({
+ propStatuses,
+ nodePath: previousNodePath,
+ })
+ ) {
+ return null;
+ }
+
+ const previousRuntimeValues =
+ previousControls.runtimeValues.getSnapshot();
+ const previousPlaybackRate = getTrimPlaybackRate({
+ sequence: previous,
+ runtimeValues: previousRuntimeValues,
+ });
+ rollingPrevious = {
+ fileName: previousNodePath.absolutePath,
+ // The preceding clip may have moved via a drag override before
+ // its runtime snapshot catches up with the saved source edit.
+ initialDuration: previous.duration,
+ minimumDuration: 1,
+ nodePath: previousNodePath,
+ playbackRate: previousPlaybackRate,
+ schema: previousControls.schema,
+ };
+ }
+ }
+
targets.set(key, {
parentPlaybackRate: getParentSequencePlaybackRate(
originalSequence,
@@ -1004,15 +1125,18 @@ export const getTimelineSequenceLeftEdgeDragTargets = ({
),
fileName: nodePath.absolutePath,
initialDuration:
- typeof runtimeDuration === 'number' &&
- Number.isFinite(runtimeDuration)
- ? runtimeDuration / playbackRate
- : originalSequence.duration,
+ isSeriesSequence(originalSequence) ||
+ typeof runtimeDuration !== 'number' ||
+ !Number.isFinite(runtimeDuration)
+ ? originalSequence.duration
+ : runtimeDuration / playbackRate,
initialFrom: positionField === 'from' ? originalSequence.from : 0,
- initialTrimBefore: trimsMedia
- ? (originalSequence.trimBefore ??
- Math.max(0, originalSequence.startMediaFrom))
- : (originalSequence.trimBefore ?? 0),
+ initialTrimBefore: trimBeforeOnly
+ ? ownTrimBefore
+ : trimsMedia
+ ? (originalSequence.trimBefore ??
+ Math.max(0, originalSequence.startMediaFrom))
+ : (originalSequence.trimBefore ?? 0),
minimumDuration: getMinimumSequenceDuration({
sequence: originalSequence,
sequences,
@@ -1020,6 +1144,7 @@ export const getTimelineSequenceLeftEdgeDragTargets = ({
nodePath,
playbackRate,
positionField,
+ rollingPrevious,
schema: controls.schema,
});
}
@@ -1199,6 +1324,9 @@ const clearLeftEdgeDragOverrides = ({
}) => {
for (const target of targets) {
clearDragOverrides(target.nodePath);
+ if (target.rollingPrevious) {
+ clearDragOverrides(target.rollingPrevious.nodePath);
+ }
}
};
@@ -1250,17 +1378,23 @@ const clearFromDragOverrides = ({
const TimelineSequenceLeftEdgeDragHandleInner: React.FC<{
readonly cursor: string;
+ readonly trimBeforeCursor: string;
+ readonly edgeEnabled: boolean;
+ readonly trimBeforeEnabled: boolean;
readonly nodePathInfo: SequenceNodePathInfo;
readonly windowWidth: number;
readonly timelineDurationInFrames: number;
readonly initialEdgeFrame: number;
readonly fps: number;
- readonly onDragStart: () => void;
+ readonly onDragStart: (trimBeforeOnly: boolean) => void;
readonly onDragEnd: (wasDragged: boolean) => void;
readonly onSelect: (interaction?: TimelineSelectionInteraction) => void;
readonly selected: boolean;
}> = ({
cursor,
+ trimBeforeCursor,
+ edgeEnabled,
+ trimBeforeEnabled,
nodePathInfo,
windowWidth,
timelineDurationInFrames,
@@ -1295,6 +1429,7 @@ const TimelineSequenceLeftEdgeDragHandleInner: React.FC<{
pointerId: number;
selectionInteraction: TimelineSelectionInteraction | null;
targets: readonly TimelineSequenceLeftEdgeDragTarget[];
+ trimBeforeOnly: boolean;
} | null>(null);
const latestRef = useRef({
@@ -1349,6 +1484,7 @@ const TimelineSequenceLeftEdgeDragHandleInner: React.FC<{
const changes = getTimelineSequenceLeftEdgeDragChanges({
targets: dragState.targets,
deltaFrames: dragState.latestDeltaFrames,
+ trimBeforeOnly: dragState.trimBeforeOnly,
});
if (
@@ -1369,12 +1505,18 @@ const TimelineSequenceLeftEdgeDragHandleInner: React.FC<{
changes,
setPropStatuses: latestSetPropStatuses,
clientId: latestServerState.clientId,
- undoLabel:
- dragState.targets.length > 1
+ undoLabel: dragState.trimBeforeOnly
+ ? dragState.targets.length > 1
+ ? 'Adjust source start of selected sequences'
+ : 'Adjust source start'
+ : dragState.targets.length > 1
? 'Resize selected sequences'
: 'Resize sequence',
- redoLabel:
- dragState.targets.length > 1
+ redoLabel: dragState.trimBeforeOnly
+ ? dragState.targets.length > 1
+ ? 'Adjust source start of selected sequences back'
+ : 'Adjust source start back'
+ : dragState.targets.length > 1
? 'Resize selected sequences back'
: 'Resize sequence back',
});
@@ -1401,6 +1543,9 @@ const TimelineSequenceLeftEdgeDragHandleInner: React.FC<{
return;
}
+ const trimBeforeOnly = e.currentTarget.dataset.trimMode === 'source';
+ const activeCursor = trimBeforeOnly ? trimBeforeCursor : cursor;
+
e.stopPropagation();
e.preventDefault();
@@ -1429,6 +1574,7 @@ const TimelineSequenceLeftEdgeDragHandleInner: React.FC<{
sequences: sequencesRef.current,
overrideIdsToNodePaths: latestOverrideIdsToNodePaths,
propStatuses: propStatusesRef.current,
+ trimBeforeOnly,
}) ?? [])
: [];
const draggedKey = stringifySequenceSubscriptionKey(
@@ -1443,7 +1589,7 @@ const TimelineSequenceLeftEdgeDragHandleInner: React.FC<{
const initialTimelineEdge = latestRef.current.initialEdgeFrame;
stopPointerSessionRef.current?.();
- onDragStart();
+ onDragStart(trimBeforeOnly);
dragStateRef.current = {
initialClientX: e.clientX,
latestDeltaFrames: 0,
@@ -1452,10 +1598,11 @@ const TimelineSequenceLeftEdgeDragHandleInner: React.FC<{
pointerId: e.pointerId,
selectionInteraction,
targets,
+ trimBeforeOnly,
};
document.body.style.userSelect = 'none';
document.body.style.webkitUserSelect = 'none';
- forceSpecificCursor(cursor);
+ forceSpecificCursor(activeCursor);
const onMove = (pointerEvent: PointerEvent) => {
const dragState = dragStateRef.current;
@@ -1471,6 +1618,7 @@ const TimelineSequenceLeftEdgeDragHandleInner: React.FC<{
getTimelineSequenceLeftEdgeDragChanges({
targets: dragState.targets,
deltaFrames,
+ trimBeforeOnly: dragState.trimBeforeOnly,
}).length > 0
) {
dragState.didMove = true;
@@ -1484,8 +1632,27 @@ const TimelineSequenceLeftEdgeDragHandleInner: React.FC<{
deltaFrames: deltaFrames * target.parentPlaybackRate,
playbackRate: target.playbackRate,
minimumDuration: target.minimumDuration,
+ minimumDeltaFrames: target.rollingPrevious
+ ? target.rollingPrevious.minimumDuration -
+ target.rollingPrevious.initialDuration
+ : -Infinity,
+ trimBeforeOnly: dragState.trimBeforeOnly,
});
- if (target.positionField !== null) {
+ if (target.rollingPrevious && !dragState.trimBeforeOnly) {
+ const previous = target.rollingPrevious;
+ latestRef.current.setDragOverrides(
+ previous.nodePath,
+ 'durationInFrames',
+ Internals.makeStaticDragOverride(
+ (previous.initialDuration +
+ target.initialDuration -
+ nextValues.durationInFrames) *
+ previous.playbackRate,
+ ),
+ );
+ }
+
+ if (!dragState.trimBeforeOnly && target.positionField !== null) {
latestRef.current.setDragOverrides(
target.nodePath,
target.positionField,
@@ -1493,13 +1660,15 @@ const TimelineSequenceLeftEdgeDragHandleInner: React.FC<{
);
}
- latestRef.current.setDragOverrides(
- target.nodePath,
- 'durationInFrames',
- Internals.makeStaticDragOverride(
- nextValues.durationInFrames * target.playbackRate,
- ),
- );
+ if (!dragState.trimBeforeOnly) {
+ latestRef.current.setDragOverrides(
+ target.nodePath,
+ 'durationInFrames',
+ Internals.makeStaticDragOverride(
+ nextValues.durationInFrames * target.playbackRate,
+ ),
+ );
+ }
latestRef.current.setDragOverrides(
target.nodePath,
@@ -1516,10 +1685,22 @@ const TimelineSequenceLeftEdgeDragHandleInner: React.FC<{
deltaFrames,
playbackRate: draggedTarget.playbackRate,
minimumDuration: draggedTarget.minimumDuration,
+ minimumDeltaFrames: draggedTarget.rollingPrevious
+ ? draggedTarget.rollingPrevious.minimumDuration -
+ draggedTarget.rollingPrevious.initialDuration
+ : -Infinity,
+ trimBeforeOnly: dragState.trimBeforeOnly,
});
- const appliedDelta = values.from - draggedTarget.initialFrom;
+ const appliedDelta = dragState.trimBeforeOnly
+ ? (values.trimBefore - draggedTarget.initialTrimBefore) /
+ draggedTarget.playbackRate
+ : values.from - draggedTarget.initialFrom;
const edgeDelta =
- draggedTarget.positionField === null ? 0 : appliedDelta;
+ dragState.trimBeforeOnly ||
+ (draggedTarget.positionField === null &&
+ draggedTarget.rollingPrevious === null)
+ ? 0
+ : appliedDelta;
setTrimTooltip({
deltaFrames: appliedDelta,
edgeFrame: initialTimelineEdge + edgeDelta,
@@ -1574,6 +1755,7 @@ const TimelineSequenceLeftEdgeDragHandleInner: React.FC<{
selected,
sequencesRef,
timelineDurationInFrames,
+ trimBeforeCursor,
windowWidth,
],
);
@@ -1585,22 +1767,42 @@ const TimelineSequenceLeftEdgeDragHandleInner: React.FC<{
};
}, []);
- const style: React.CSSProperties = {
+ const edgeStyle: React.CSSProperties = {
...baseStyle,
left: -HANDLE_OUTSET,
+ width: 'calc(8px + min(4px, 12.5%))',
cursor,
background: TRANSPARENT,
};
+ const trimBeforeStyle: React.CSSProperties = {
+ ...baseStyle,
+ left: edgeEnabled ? 'min(4px, 12.5%)' : 0,
+ width: edgeEnabled ? 'min(10px, 12.5%)' : 'min(14px, 25%)',
+ cursor: trimBeforeCursor,
+ background: TRANSPARENT,
+ };
return (
<>
- <div
- role="separator"
- aria-orientation="vertical"
- aria-label="Drag to trim start"
- style={style}
- onPointerDown={onPointerDown}
- />
+ {edgeEnabled ? (
+ <div
+ role="separator"
+ aria-orientation="vertical"
+ aria-label="Drag to trim start"
+ style={edgeStyle}
+ onPointerDown={onPointerDown}
+ />
+ ) : null}
+ {trimBeforeEnabled ? (
+ <div
+ role="separator"
+ aria-orientation="vertical"
+ aria-label="Drag to adjust source start"
+ data-trim-mode="source"
+ style={trimBeforeStyle}
+ onPointerDown={onPointerDown}
+ />
+ ) : null}
{trimTooltip === null ? null : (
<TimelineTrimTooltip state={trimTooltip} fps={fps} />
)}
diff --git a/packages/studio/src/components/Timeline/timeline-right-edge-cursor.ts b/packages/studio/src/components/Timeline/timeline-right-edge-cursor.ts
deleted file mode 100644
index 8c7118f75c..0000000000
--- a/packages/studio/src/components/Timeline/timeline-right-edge-cursor.ts
+++ /dev/null
@@ -1,14 +0,0 @@
-const timelineRightEdgeCursorSvg = `<svg width="24" height="24" viewBox="0 0 32 32" fill="none" xmlns="http://www.w3.org/2000/svg">
-<g transform="translate(32 0) scale(-1 1)" filter="url(#shadow)">
-<path d="M3 16L12 10V22L3 16Z" fill="black" stroke="white" stroke-width="1.5" stroke-linejoin="round"/>
-<path d="M23 4.5H18C16.9 4.5 16 5.4 16 6.5V25.5C16 26.6 16.9 27.5 18 27.5H23" stroke="white" stroke-width="5" stroke-linecap="round" stroke-linejoin="round"/>
-<path d="M23 4.5H18C16.9 4.5 16 5.4 16 6.5V25.5C16 26.6 16.9 27.5 18 27.5H23" stroke="black" stroke-width="2.5" stroke-linecap="round" stroke-linejoin="round"/>
-</g>
-<defs>
-<filter id="shadow" x="0" y="0" width="32" height="32" filterUnits="userSpaceOnUse">
-<feDropShadow dx="0" dy="1.5" stdDeviation="1" flood-color="black" flood-opacity="0.35"/>
-</filter>
-</defs>
-</svg>`;
-
-export const timelineRightEdgeCursor = `url("data:image/svg+xml,${encodeURIComponent(timelineRightEdgeCursorSvg)}") 12 12`;
diff --git a/packages/studio/src/components/Timeline/timeline-ripple-edge-cursor.ts b/packages/studio/src/components/Timeline/timeline-trim-edge-cursor.ts
similarity index 72%
rename from packages/studio/src/components/Timeline/timeline-ripple-edge-cursor.ts
rename to packages/studio/src/components/Timeline/timeline-trim-edge-cursor.ts
index b4dfba9758..14c8caa44e 100644
--- a/packages/studio/src/components/Timeline/timeline-ripple-edge-cursor.ts
+++ b/packages/studio/src/components/Timeline/timeline-trim-edge-cursor.ts
@@ -1,4 +1,4 @@
-const timelineRippleEdgeCursorSvg = `<svg width="24" height="24" viewBox="0 0 32 32" fill="none" xmlns="http://www.w3.org/2000/svg">
+const timelineTrimEdgeCursorSvg = `<svg width="24" height="24" viewBox="0 0 32 32" fill="none" xmlns="http://www.w3.org/2000/svg">
<g filter="url(#shadow)">
<path d="M7 4.5H11C12.1 4.5 13 5.4 13 6.5V25.5C13 26.6 12.1 27.5 11 27.5H7M25 4.5H21C19.9 4.5 19 5.4 19 6.5V25.5C19 26.6 19.9 27.5 21 27.5H25" stroke="white" stroke-width="5" stroke-linecap="round" stroke-linejoin="round"/>
<path d="M7 4.5H11C12.1 4.5 13 5.4 13 6.5V25.5C13 26.6 12.1 27.5 11 27.5H7M25 4.5H21C19.9 4.5 19 5.4 19 6.5V25.5C19 26.6 19.9 27.5 21 27.5H25" stroke="black" stroke-width="2.5" stroke-linecap="round" stroke-linejoin="round"/>
@@ -10,4 +10,4 @@ const timelineRippleEdgeCursorSvg = `<svg width="24" height="24" viewBox="0 0 32
</defs>
</svg>`;
-export const timelineRippleEdgeCursor = `url("data:image/svg+xml,${encodeURIComponent(timelineRippleEdgeCursorSvg)}") 12 12`;
+export const timelineTrimEdgeCursor = `url("data:image/svg+xml,${encodeURIComponent(timelineTrimEdgeCursorSvg)}") 12 12`;