Skip to content

🎥 Make videos programmatically with React

5.4 KB
Raw Blame
import type {SetStateAction} from 'react';
import React, {useCallback, useContext, useMemo, useState} from 'react';
import {getBrowserStudioOperations} from '../helpers/browser-studio-operations';
import {canShowUpdates} from '../helpers/can-show-updates';
import {StudioServerConnectionCtx} from '../helpers/client-id';
import {BACKGROUND, BORDER_BLACK, WHITE} from '../helpers/colors';
import {useMobileLayout} from '../helpers/mobile-layout';
import {useToolbarMenuStructure} from '../helpers/use-menu-structure';
import {Row} from './layout';
import {MENU_TOOLBAR_HEIGHT} from './menu-toolbar-height';
import type {MenuId} from './Menu/MenuItem';
import {MenuItem} from './Menu/MenuItem';
import {MenuBuildIndicator} from './MenuBuildIndicator';
import {SettingsButton} from './SettingsButton';
import {SidebarCollapserControl} from './SidebarCollapserControls';
import {
	CompositionToolbarMenuItem,
	FileToolbarMenuItem,
	MobileToolbarMenuItem,
} from './ToolbarMenuItems';
import {UndoRedoButtons} from './UndoRedoButtons';

const row: React.CSSProperties = {
	alignItems: 'center',
	flexDirection: 'row',
	display: 'flex',
	color: WHITE,
	borderBottom: BORDER_BLACK,
	boxSizing: 'border-box',
	fontSize: 13,
	height: MENU_TOOLBAR_HEIGHT,
	paddingLeft: 6,
	paddingRight: 6,
	backgroundColor: BACKGROUND,
};

const flex: React.CSSProperties = {
	flex: 1,
};

const menuItems: React.CSSProperties = {
	display: 'inline-flex',
	height: 24,
};

export const MenuToolbar: React.FC<{
	readonly readOnlyStudio: boolean;
}> = React.memo(({readOnlyStudio}) => {
	const [selected, setSelected] = useState<string | null>(null);
	const {previewServerState} = useContext(StudioServerConnectionCtx);
	const browserStudioOperations = getBrowserStudioOperations();
	const canUndoAndRedo =
		!readOnlyStudio ||
		(previewServerState.type === 'connected' &&
			browserStudioOperations !== null);
	const showUpdates = canShowUpdates({
		connectionStatus: previewServerState.type,
		isBrowserStudio: browserStudioOperations !== null,
		readOnlyStudio,
	});

	const mobileLayout = useMobileLayout();

	const fixedWidthRight: React.CSSProperties = useMemo(() => {
		return {
			...(mobileLayout
				? {width: 'fit-content'}
				: {
						width: '330px',
					}),
			display: 'flex',
			alignItems: 'center',
			justifyContent: 'flex-end',
		};
	}, [mobileLayout]);

	const fixedWidthLeft: React.CSSProperties = useMemo(() => {
		return {
			...(mobileLayout
				? {minWidth: '0px'}
				: {
						minWidth: '330px',
					}),
			display: 'flex',
			flexShrink: 0,
			alignItems: 'center',
			justifyContent: 'flex-start',
		};
	}, [mobileLayout]);

	const itemClicked = useCallback(
		(itemId: SetStateAction<string | null>) => {
			setSelected(itemId);
		},
		[setSelected],
	);

	const itemHovered = useCallback(
		(itemId: MenuId) => {
			if (selected) {
				setSelected(itemId);
			}
		},
		[selected, setSelected],
	);

	const closeMenu = useCallback(() => {
		setSelected(null);
	}, []);

	const structure = useToolbarMenuStructure(closeMenu, readOnlyStudio);

	const menuIdsKey = structure.map((s) => s.id).join('|');
	const menus = useMemo(() => menuIdsKey.split('|') as MenuId[], [menuIdsKey]);

	const onPreviousMenu = useCallback(() => {
		setSelected((s) => {
			if (s === null) {
				return null;
			}

			return menus[(menus.indexOf(s as MenuId) + 1) % menus.length];
		});
	}, [menus]);

	const onNextMenu = useCallback(() => {
		setSelected((s) => {
			if (s === null) {
				return null;
			}

			if (menus.indexOf(s as MenuId) === 0) {
				return menus[menus.length - 1];
			}

			return menus[(menus.indexOf(s as MenuId) - 1) % menus.length];
		});
	}, [menus]);

	const onItemQuit = useCallback(() => {
		setSelected(null);
	}, [setSelected]);

	const onPointerDown = useCallback((e: React.PointerEvent<HTMLDivElement>) => {
		// Prevent deselection of currently selected items
		e.stopPropagation();
	}, []);

	return (
		<Row
			align="center"
			className="css-reset"
			style={row}
			onPointerDown={onPointerDown}
		>
			<div style={fixedWidthLeft}>
				<SidebarCollapserControl side="left" />
				<div style={menuItems}>
					{structure.map((s) => {
						const props = {
							selected: selected === s.id,
							onItemSelected: itemClicked,
							onItemHovered: itemHovered,
							onItemQuit,
							onPreviousMenu,
							onNextMenu,
						};
						if (mobileLayout) {
							return (
								<MobileToolbarMenuItem
									key={s.id}
									{...props}
									closeMenu={closeMenu}
									readOnlyStudio={readOnlyStudio}
								/>
							);
						}

						if (s.id === 'file') {
							return (
								<FileToolbarMenuItem
									key={s.id}
									{...props}
									closeMenu={closeMenu}
									readOnlyStudio={readOnlyStudio}
								/>
							);
						}

						if (s.id === 'composition') {
							return (
								<CompositionToolbarMenuItem
									key={s.id}
									{...props}
									closeMenu={closeMenu}
									readOnlyStudio={readOnlyStudio}
								/>
							);
						}

						return (
							<MenuItem
								key={s.id}
								{...props}
								id={s.id}
								label={s.label}
								menu={s}
								leaveLeftPadding={s.leaveLeftPadding}
							/>
						);
					})}
				</div>
			</div>
			{mobileLayout ? null : <div style={flex} />}
			<MenuBuildIndicator mobileLayout={mobileLayout} />
			<div style={flex} />
			<div style={fixedWidthRight}>
				{canUndoAndRedo ? <UndoRedoButtons /> : null}
				<SettingsButton showUpdates={showUpdates} />
				<SidebarCollapserControl side="right" />
			</div>
		</Row>
	);
});