Skip to content

🎥 Make videos programmatically with React

7.6 KB
Raw Blame
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>
	);
};