🎥 Make videos programmatically with React
import type {SVGProps} from 'react';
import React, {useCallback, useContext, useMemo} from 'react';
import {WHITE_ALPHA_80} from '../helpers/colors';
import {areKeyboardShortcutsDisabled} from '../helpers/use-keybinding';
import {useKeyboardShortcutLabel} from '../helpers/use-keyboard-shortcut-label';
import {Checkmark} from '../icons/Checkmark';
import {EllipsisIcon} from '../icons/ellipsis';
import {CheckerboardContext} from '../state/checkerboard';
import {EditorShowGuidesContext} from '../state/editor-guides';
import {EditorShowOutlinesContext} from '../state/editor-outlines';
import {EditorShowPixelGridContext} from '../state/editor-pixel-grid';
import {EditorShowRulersContext} from '../state/editor-rulers';
import {ActionTooltip} from './ActionTooltip';
import type {RenderInlineAction} from './InlineAction';
import {InlineDropdown} from './InlineDropdown';
import {toggleLoop} from './LoopToggle';
import type {ComboboxValue} from './NewComposition/ComboBox';
import {usePlaybackRateMenuItems} from './PlaybackRateSelector';
import {usePreviewSizeMenuItems} from './SizeSelector';
const clickButton = (id: string) => {
(document.getElementById(id) as HTMLButtonElement | null)?.click();
};
export const PreviewToolbarOverflowButton: React.FC<{
readonly showFullscreen: boolean;
readonly showPlaybackRate: boolean;
readonly showLoop: boolean;
readonly showCanvasViewControls: boolean;
readonly showCompositionControls: boolean;
readonly playbackRate: number;
readonly setPlaybackRate: React.Dispatch<React.SetStateAction<number>>;
readonly loop: boolean;
readonly setLoop: React.Dispatch<React.SetStateAction<boolean>>;
}> = ({
showFullscreen,
showPlaybackRate,
showLoop,
showCanvasViewControls,
showCompositionControls,
playbackRate,
setPlaybackRate,
loop,
setLoop,
}) => {
const keyboardShortcutsDisabled = areKeyboardShortcutsDisabled();
const fullscreenShortcut = useKeyboardShortcutLabel('enterFullscreen');
const loopShortcut = useKeyboardShortcutLabel('toggleLoop');
const outlinesShortcut = useKeyboardShortcutLabel('toggleOutlines');
const pixelGridShortcut = useKeyboardShortcutLabel('togglePixelGrid');
const checkerboardShortcut = useKeyboardShortcutLabel('toggleCheckerboard');
const {checkerboard, setCheckerboard} = useContext(CheckerboardContext);
const {editorShowOutlines, setEditorShowOutlines} = useContext(
EditorShowOutlinesContext,
);
const {editorShowGuides, setEditorShowGuides} = useContext(
EditorShowGuidesContext,
);
const {editorShowRulers, setEditorShowRulers} = useContext(
EditorShowRulersContext,
);
const {editorShowPixelGrid, setEditorShowPixelGrid} = useContext(
EditorShowPixelGridContext,
);
const {
items: previewSizeItems,
selectedId: selectedPreviewSize,
zoomable,
} = usePreviewSizeMenuItems();
const {items: playbackRateItems, selectedId: selectedPlaybackRate} =
usePlaybackRateMenuItems({playbackRate, setPlaybackRate});
const iconStyle: SVGProps<SVGSVGElement> = useMemo(() => {
return {
style: {
width: 14,
height: 14,
flexShrink: 0,
},
};
}, []);
const renderAction: RenderInlineAction = useCallback(
(color) => <EllipsisIcon fill={color} svgProps={iconStyle} />,
[iconStyle],
);
const values = useMemo((): ComboboxValue[] => {
const items: ComboboxValue[] = [];
if (zoomable) {
items.push({
type: 'item',
id: 'preview-size',
label: 'Preview Size',
value: 'preview-size',
onClick: () => undefined,
keyHint: null,
leftItem: null,
subMenu: {
items: previewSizeItems,
leaveLeftSpace: true,
preselectIndex: previewSizeItems.findIndex(
(item) => item.id === selectedPreviewSize,
),
},
quickSwitcherLabel: null,
});
}
if (showPlaybackRate) {
items.push({
type: 'item',
id: 'playback-rate',
label: 'Playback Rate',
value: 'playback-rate',
onClick: () => undefined,
keyHint: null,
leftItem: null,
subMenu: {
items: playbackRateItems,
leaveLeftSpace: true,
preselectIndex: playbackRateItems.findIndex(
(item) => item.id === selectedPlaybackRate,
),
},
quickSwitcherLabel: null,
});
}
if (showLoop) {
items.push({
type: 'item',
id: 'loop',
label: 'Loop',
value: 'loop',
onClick: () => toggleLoop(setLoop),
keyHint:
keyboardShortcutsDisabled || loopShortcut === ''
? null
: loopShortcut,
leftItem: loop ? <Checkmark /> : null,
subMenu: null,
quickSwitcherLabel: null,
});
}
if (showCanvasViewControls) {
items.push({
type: 'item',
id: 'checkerboard',
label: 'Transparency as checkerboard',
value: 'checkerboard',
onClick: () => setCheckerboard((current) => !current),
keyHint:
keyboardShortcutsDisabled || checkerboardShortcut === ''
? null
: checkerboardShortcut,
leftItem: checkerboard ? <Checkmark /> : null,
subMenu: null,
quickSwitcherLabel: null,
});
}
if (showCompositionControls) {
items.push({
type: 'item',
id: 'outlines',
label: 'Outlines',
value: 'outlines',
onClick: () => setEditorShowOutlines((current) => !current),
keyHint: keyboardShortcutsDisabled ? null : outlinesShortcut || null,
leftItem: editorShowOutlines ? <Checkmark /> : null,
subMenu: null,
quickSwitcherLabel: null,
});
}
if (showCanvasViewControls) {
items.push({
type: 'item',
id: 'rulers',
label: 'Rulers',
value: 'rulers',
onClick: () => setEditorShowRulers((current) => !current),
keyHint: null,
leftItem: editorShowRulers ? <Checkmark /> : null,
subMenu: null,
quickSwitcherLabel: null,
});
}
if (showCompositionControls) {
items.push({
type: 'item',
id: 'guides',
label: 'Guides',
value: 'guides',
onClick: () => setEditorShowGuides((current) => !current),
keyHint: null,
leftItem: editorShowGuides ? <Checkmark /> : null,
subMenu: null,
quickSwitcherLabel: null,
});
}
if (showCanvasViewControls) {
items.push({
type: 'item',
id: 'pixel-grid',
label: 'Pixel Grid',
value: 'pixel-grid',
onClick: () => setEditorShowPixelGrid((current) => !current),
keyHint: keyboardShortcutsDisabled ? null : pixelGridShortcut || null,
leftItem: editorShowPixelGrid ? <Checkmark /> : null,
subMenu: null,
quickSwitcherLabel: null,
});
}
if (showFullscreen) {
items.push({
type: 'item',
id: 'fullscreen',
label: 'Fullscreen',
value: 'fullscreen',
onClick: () => clickButton('fullscreen-toggle'),
keyHint:
keyboardShortcutsDisabled || fullscreenShortcut === ''
? null
: fullscreenShortcut,
leftItem: null,
subMenu: null,
quickSwitcherLabel: null,
});
}
return items;
}, [
checkerboardShortcut,
fullscreenShortcut,
loopShortcut,
previewSizeItems,
playbackRateItems,
selectedPlaybackRate,
selectedPreviewSize,
showFullscreen,
showLoop,
showPlaybackRate,
showCanvasViewControls,
showCompositionControls,
loop,
checkerboard,
editorShowGuides,
editorShowOutlines,
outlinesShortcut,
pixelGridShortcut,
editorShowRulers,
editorShowPixelGrid,
setCheckerboard,
setEditorShowGuides,
setEditorShowOutlines,
setEditorShowRulers,
setEditorShowPixelGrid,
setLoop,
zoomable,
keyboardShortcutsDisabled,
]);
if (values.length === 0) {
return null;
}
return (
<ActionTooltip
label="View options"
shortcut={null}
delay={800}
dismissOnClick
>
<InlineDropdown
variant={null}
renderAction={renderAction}
values={values}
aria-label="More actions"
unhoveredColor={WHITE_ALPHA_80}
/>
</ActionTooltip>
);
};