🎥 Make videos programmatically with React
import React, {useCallback, useContext, useMemo} from 'react';
import {TIMELINE_TRACK_SEPARATOR} from '../../helpers/colors';
import {createDragAwareDoubleClickTracker} from '../../helpers/drag-aware-double-click';
import {Padder} from './Padder';
import {
getTimelineRowIndentWidth,
getTimelineRowLeftChromeWidth,
} from './timeline-row-layout';
import {TimelineRowLayoutContext} from './TimelineRowLayoutContext';
import type {TimelineSelectionInteraction} from './TimelineSelection';
import {
getTimelineRowHighlightBackground,
isTimelineSelectionModifierEvent,
TIMELINE_SELECTED_BACKGROUND,
} from './TimelineSelection';
export const TimelineRowSelectedBackgroundContext = React.createContext<string>(
TIMELINE_SELECTED_BACKGROUND,
);
const rowBase: React.CSSProperties = {
alignItems: 'stretch',
display: 'flex',
};
const leftChromeStyle: React.CSSProperties = {
alignItems: 'center',
alignSelf: 'stretch',
display: 'flex',
flexShrink: 0,
};
const keyframeControlsColumnBaseStyle: React.CSSProperties = {
alignItems: 'center',
display: 'flex',
flexShrink: 0,
justifyContent: 'flex-start',
};
export const TimelineRowKeyframeControlsColumn: React.FC<{
readonly children: React.ReactNode;
readonly depth: number;
}> = ({children, depth}) => {
const {basePadding, keyframeControlsPadding} = useContext(
TimelineRowLayoutContext,
);
const style = useMemo(
(): React.CSSProperties => ({
...keyframeControlsColumnBaseStyle,
boxSizing: keyframeControlsPadding === 0 ? undefined : 'border-box',
paddingLeft: keyframeControlsPadding,
width: getTimelineRowLeftChromeWidth(depth, basePadding),
}),
[basePadding, depth, keyframeControlsPadding],
);
return (
<div style={leftChromeStyle}>
<div style={style}>{children}</div>
</div>
);
};
export const TimelineRowChrome: React.FC<{
readonly depth: number;
readonly eye: React.ReactNode;
readonly keyframeControls?: React.ReactNode;
readonly arrow: React.ReactNode;
readonly children: React.ReactNode;
readonly style: React.CSSProperties;
readonly selected: boolean;
readonly selectable: boolean;
readonly onSelect: (interaction?: TimelineSelectionInteraction) => void;
readonly showSelectedBackground: boolean;
readonly containsSelection: boolean;
readonly hovered?: boolean;
// When set, the chrome is wrapped in an outer container of this height with a
// bottom track separator. The background highlight and click target span the
// outer (used by sequence rows whose layer is taller than the chrome row).
readonly outerHeight: number | null;
readonly showBottomBorder: boolean;
readonly onDragLeave?: (e: React.DragEvent<HTMLDivElement>) => void;
readonly onDragOver?: (e: React.DragEvent<HTMLDivElement>) => void;
readonly onDrop?: (e: React.DragEvent<HTMLDivElement>) => void;
readonly onDoubleClick?: (e: React.MouseEvent<HTMLDivElement>) => void;
readonly onPointerEnter?: () => void;
readonly onPointerLeave?: () => void;
}> = ({
depth,
eye,
keyframeControls,
arrow,
children,
style,
selected,
selectable,
onSelect,
showSelectedBackground,
containsSelection,
hovered = false,
outerHeight,
showBottomBorder,
onDragLeave,
onDragOver,
onDrop,
onDoubleClick,
onPointerEnter,
onPointerLeave,
}) => {
const {basePadding, rowBorderRadius, rowHorizontalMargin} = useContext(
TimelineRowLayoutContext,
);
const selectedBackground = useContext(TimelineRowSelectedBackgroundContext);
const doubleClickTracker = useMemo(
() => createDragAwareDoubleClickTracker(),
[],
);
const indentWidth = getTimelineRowIndentWidth(depth);
const chromeColumnStyle = useMemo(
(): React.CSSProperties => ({
alignItems: 'center',
alignSelf: 'stretch',
display: 'flex',
flexShrink: 0,
paddingLeft: basePadding,
}),
[basePadding],
);
const onPointerDown = useCallback(
(e: React.PointerEvent<HTMLDivElement>) => {
if (e.button === 0) {
e.stopPropagation();
if (isTimelineSelectionModifierEvent(e)) {
onSelect({
shiftKey: e.shiftKey,
toggleKey: e.metaKey || e.ctrlKey,
});
}
}
},
[onSelect],
);
const onContextMenu = useCallback(
(e: React.MouseEvent<HTMLDivElement>) => {
e.stopPropagation();
if (!selected) {
onSelect();
}
},
[onSelect, selected],
);
const onClick = useCallback(
(e: React.MouseEvent<HTMLDivElement>) => {
const {target} = e;
if (
target instanceof Element &&
e.currentTarget.contains(
target.closest(
'button, input, select, textarea, a, [contenteditable="true"]',
),
)
) {
e.stopPropagation();
return;
}
if (
selectable &&
e.button === 0 &&
!isTimelineSelectionModifierEvent(e)
) {
onSelect();
}
if (!doubleClickTracker.acceptClickAsDoubleClick(e)) {
return;
}
onDoubleClick?.(e);
},
[doubleClickTracker, onDoubleClick, onSelect, selectable],
);
const highlightBackground = getTimelineRowHighlightBackground({
showSelectedBackground,
selected,
containsSelection,
hovered,
selectedBackground,
});
const innerRowStyle = useMemo(
(): React.CSSProperties => ({
...rowBase,
...style,
backgroundColor: outerHeight === null ? highlightBackground : undefined,
borderRadius: rowBorderRadius,
margin: `0 ${rowHorizontalMargin}px`,
}),
[
style,
outerHeight,
highlightBackground,
rowBorderRadius,
rowHorizontalMargin,
],
);
const outerStyle = useMemo((): React.CSSProperties | undefined => {
if (outerHeight === null) {
return undefined;
}
return {
height: outerHeight,
borderBottom: `1px solid ${showBottomBorder ? TIMELINE_TRACK_SEPARATOR : 'transparent'}`,
display: 'flex',
flexDirection: 'column',
justifyContent: 'center',
backgroundColor: highlightBackground,
};
}, [outerHeight, highlightBackground, showBottomBorder]);
const chrome = (
<>
{keyframeControls ? (
<TimelineRowKeyframeControlsColumn depth={depth}>
{keyframeControls}
</TimelineRowKeyframeControlsColumn>
) : (
<div style={leftChromeStyle}>
<div style={chromeColumnStyle}>
{eye}
{indentWidth > 0 ? <Padder depth={depth} /> : null}
{arrow}
</div>
</div>
)}
{children}
</>
);
if (outerStyle) {
return (
<div
style={outerStyle}
onDragLeave={onDragLeave}
onDragOver={onDragOver}
onDrop={onDrop}
onPointerDownCapture={doubleClickTracker.beginPointerGesture}
onPointerDown={selectable ? onPointerDown : undefined}
onClick={onClick}
onContextMenu={selectable ? onContextMenu : undefined}
onPointerEnter={onPointerEnter}
onPointerLeave={onPointerLeave}
>
<div style={innerRowStyle}>{chrome}</div>
</div>
);
}
return (
<div
onDragLeave={onDragLeave}
onDragOver={onDragOver}
onDrop={onDrop}
onPointerDownCapture={doubleClickTracker.beginPointerGesture}
onPointerDown={selectable ? onPointerDown : undefined}
onClick={onClick}
onContextMenu={selectable ? onContextMenu : undefined}
onPointerEnter={onPointerEnter}
onPointerLeave={onPointerLeave}
style={innerRowStyle}
>
{chrome}
</div>
);
};