Menubar

Desktop application style menubar with a row of menu triggers

Usage

Menubar is a horizontal row of menu triggers (File, Edit, View), each opening a dropdown. It is built on top of Menu: dropdown content is composed from Menu.Item, Menu.Divider and other Menu components:

import { Menu, Menubar, Text } from '@mantine/core';

function Demo() {
  return (
    <Menubar aria-label="Application menu">
      <Menubar.Menu width={220}>
        <Menubar.Target>File</Menubar.Target>
        <Menubar.Dropdown>
          <Menu.Item rightSection={<Text size="xs">⌘N</Text>}>New file</Menu.Item>
          <Menu.Item rightSection={<Text size="xs">⌘⇧N</Text>}>New window</Menu.Item>
          <Menu.Sub>
            <Menu.Sub.Target>
              <Menu.Sub.Item>Open recent</Menu.Sub.Item>
            </Menu.Sub.Target>
            <Menu.Sub.Dropdown>
              <Menu.Item>project-alpha</Menu.Item>
              <Menu.Item>project-beta</Menu.Item>
              <Menu.Item>project-gamma</Menu.Item>
            </Menu.Sub.Dropdown>
          </Menu.Sub>
          <Menu.Divider />
          <Menu.Item rightSection={<Text size="xs">⌘S</Text>}>Save</Menu.Item>
          <Menu.Item>Save as…</Menu.Item>
        </Menubar.Dropdown>
      </Menubar.Menu>

      <Menubar.Menu width={220}>
        <Menubar.Target>Edit</Menubar.Target>
        <Menubar.Dropdown>
          <Menu.Item rightSection={<Text size="xs">⌘Z</Text>}>Undo</Menu.Item>
          <Menu.Item rightSection={<Text size="xs">⌘⇧Z</Text>}>Redo</Menu.Item>
          <Menu.Divider />
          <Menu.Item>Cut</Menu.Item>
          <Menu.Item>Copy</Menu.Item>
          <Menu.Item>Paste</Menu.Item>
        </Menubar.Dropdown>
      </Menubar.Menu>

      <Menubar.Menu width={220}>
        <Menubar.Target>Help</Menubar.Target>
        <Menubar.Dropdown>
          <Menu.Item>Documentation</Menu.Item>
          <Menu.Item>Keyboard shortcuts</Menu.Item>
          <Menu.Item>About</Menu.Item>
        </Menubar.Dropdown>
      </Menubar.Menu>
    </Menubar>
  );
}

How it differs from Menu

Menu is one target that toggles one dropdown. Menubar coordinates multiple menus:

  • Only one menu is open at a time, moving to another target switches the open menu
  • The whole bar is a single tab stop, arrow keys move focus between targets

If you need a single dropdown attached to one button, use Menu instead.

Composition

  • Menubar – root element
  • Menubar.Menu – wraps a single menu, accepts the same props as Menu
  • Menubar.Target – top-level trigger button
  • Menubar.Dropdown – dropdown container, accepts the same children as Menu.Dropdown
import { Menu, Menubar } from '@mantine/core';

function Demo() {
  return (
    <Menubar>
      <Menubar.Menu>
        <Menubar.Target>File</Menubar.Target>
        <Menubar.Dropdown>
          <Menu.Item>New file</Menu.Item>
          <Menu.Item>Open…</Menu.Item>
        </Menubar.Dropdown>
      </Menubar.Menu>

      <Menubar.Menu>
        <Menubar.Target>Edit</Menubar.Target>
        <Menubar.Dropdown>
          <Menu.Item>Undo</Menu.Item>
          <Menu.Item>Redo</Menu.Item>
        </Menubar.Dropdown>
      </Menubar.Menu>
    </Menubar>
  );
}

Trigger and loop

By default, a menu opens on click, and hovering another target switches the open menu. Set trigger="hover" to open menus on hover. Set loop={false} to stop arrow key navigation from wrapping around:

import { Menu, Menubar } from '@mantine/core';

function Demo() {
  return (
    <Menubar aria-label="Application menu" trigger="hover">
      <Menubar.Menu width={220}>
        <Menubar.Target>File</Menubar.Target>
        <Menubar.Dropdown>
          <Menu.Item>New file</Menu.Item>
          <Menu.Item>New window</Menu.Item>
          <Menu.Item>Save</Menu.Item>
        </Menubar.Dropdown>
      </Menubar.Menu>

      <Menubar.Menu width={220}>
        <Menubar.Target>Edit</Menubar.Target>
        <Menubar.Dropdown>
          <Menu.Item>Undo</Menu.Item>
          <Menu.Item>Redo</Menu.Item>
          <Menu.Item>Cut</Menu.Item>
          <Menu.Item>Copy</Menu.Item>
        </Menubar.Dropdown>
      </Menubar.Menu>

      <Menubar.Menu width={220}>
        <Menubar.Target>View</Menubar.Target>
        <Menubar.Dropdown>
          <Menu.Item>Zoom in</Menu.Item>
          <Menu.Item>Zoom out</Menu.Item>
          <Menu.Item>Reset zoom</Menu.Item>
        </Menubar.Dropdown>
      </Menubar.Menu>
    </Menubar>
  );
}

Submenus

Use Menu.Sub inside Menubar.Dropdown to create nested submenus, see Menu submenus. The usage demo above has a submenu in the File menu.

Checkbox and radio items

Use Menu.CheckboxItem for toggles and Menu.RadioGroup with Menu.RadioItem for single-choice options. Clicking these items does not close the menu:

import { Menu, Menubar } from '@mantine/core';

function Demo() {
  return (
    <Menubar aria-label="Application menu">
      <Menubar.Menu width={220}>
        <Menubar.Target>View</Menubar.Target>
        <Menubar.Dropdown>
          <Menu.CheckboxItem defaultChecked>Show sidebar</Menu.CheckboxItem>
          <Menu.CheckboxItem>Show status bar</Menu.CheckboxItem>
          <Menu.Divider />
          <Menu.Label>Appearance</Menu.Label>
          <Menu.RadioGroup defaultValue="comfortable">
            <Menu.RadioItem value="compact">Compact</Menu.RadioItem>
            <Menu.RadioItem value="comfortable">Comfortable</Menu.RadioItem>
            <Menu.RadioItem value="spacious">Spacious</Menu.RadioItem>
          </Menu.RadioGroup>
        </Menubar.Dropdown>
      </Menubar.Menu>

      <Menubar.Menu width={220}>
        <Menubar.Target>Window</Menubar.Target>
        <Menubar.Dropdown>
          <Menu.Item>Minimize</Menu.Item>
          <Menu.Item>Zoom</Menu.Item>
          <Menu.Item>Bring all to front</Menu.Item>
        </Menubar.Dropdown>
      </Menubar.Menu>
    </Menubar>
  );
}

Controlled

Use openIndex and onOpenChange props to control which menu is open. openIndex is the index of the opened Menubar.Menu or null when all menus are closed. Use defaultOpenIndex to open a menu initially without controlling the state:

import { useState } from 'react';
import { Button, Group, Menu, Menubar, Stack } from '@mantine/core';

function Demo() {
  const [openIndex, setOpenIndex] = useState<number | null>(null);

  return (
    <Stack>
      <Group>
        <Button variant="default" onClick={() => setOpenIndex(0)}>Open File</Button>
        <Button variant="default" onClick={() => setOpenIndex(1)}>Open Edit</Button>
        <Button variant="default" onClick={() => setOpenIndex(null)}>Close all</Button>
      </Group>

      <Menubar aria-label="Application menu" openIndex={openIndex} onOpenChange={setOpenIndex}>
        <Menubar.Menu width={220}>
          <Menubar.Target>File</Menubar.Target>
          <Menubar.Dropdown>
            <Menu.Item>New file</Menu.Item>
            <Menu.Item>Save</Menu.Item>
          </Menubar.Dropdown>
        </Menubar.Menu>

        <Menubar.Menu width={220}>
          <Menubar.Target>Edit</Menubar.Target>
          <Menubar.Dropdown>
            <Menu.Item>Undo</Menu.Item>
            <Menu.Item>Redo</Menu.Item>
          </Menubar.Dropdown>
        </Menubar.Menu>
      </Menubar>
    </Stack>
  );
}

Controlling with useMenubar

Menubar supports the controller pattern. Use the useMenubar hook to manage Menubar state. When controller is set, the open index and loop props of Menubar are ignored, pass them to useMenubar instead:

Opened: null, focused: 0, menus: 0. Press Alt + F to open the File menu from anywhere.

import { Button, Code, Group, Menu, Menubar, Stack, Text, useMenubar } from '@mantine/core';
import { useWindowEvent } from '@mantine/hooks';

function Demo() {
  const controller = useMenubar();

  // Alt + F opens the File menu and moves focus into it,
  // which the openIndex prop alone cannot do
  useWindowEvent('keydown', (event) => {
    if (event.altKey && event.code === 'KeyF') {
      event.preventDefault();
      controller.openMenu(0);
      controller.focusMenuItem(0, 'first');
    }
  });

  return (
    <Stack>
      <Menubar aria-label="Application menu" controller={controller}>
        <Menubar.Menu width={220}>
          <Menubar.Target>File</Menubar.Target>
          <Menubar.Dropdown>
            <Menu.Item>New file</Menu.Item>
            <Menu.Item>Save</Menu.Item>
          </Menubar.Dropdown>
        </Menubar.Menu>

        <Menubar.Menu width={220}>
          <Menubar.Target>Edit</Menubar.Target>
          <Menubar.Dropdown>
            <Menu.Item>Undo</Menu.Item>
            <Menu.Item>Redo</Menu.Item>
          </Menubar.Dropdown>
        </Menubar.Menu>

        <Menubar.Menu width={220}>
          <Menubar.Target>View</Menubar.Target>
          <Menubar.Dropdown>
            <Menu.Item>Zoom in</Menu.Item>
            <Menu.Item>Zoom out</Menu.Item>
          </Menubar.Dropdown>
        </Menubar.Menu>
      </Menubar>

      <Group>
        <Button variant="default" onClick={() => controller.focusPreviousMenu()}>
          Focus previous
        </Button>
        <Button variant="default" onClick={() => controller.focusNextMenu()}>
          Focus next
        </Button>
        <Button
          variant="default"
          onClick={() => {
            controller.openMenu(controller.getActiveIndex());
            controller.focusMenuItem(controller.getActiveIndex(), 'first');
          }}
        >
          Open focused menu
        </Button>
        <Button variant="default" onClick={controller.closeMenu}>
          Close
        </Button>
      </Group>

      <Text size="sm">
        Opened: <Code>{String(controller.getOpenIndex())}</Code>, focused:{' '}
        <Code>{controller.getActiveIndex()}</Code>, menus: <Code>{controller.getMenuCount()}</Code>. Press{' '}
        <Code>Alt + F</Code> to open the File menu from anywhere.
      </Text>
    </Stack>
  );
}

useMenubar returns the current state, actions and queries:

import { Menubar, useMenubar } from '@mantine/core';

function Demo() {
  const controller = useMenubar({
    defaultOpenIndex: 0, // -> uncontrolled initial value
    loop: false, // -> same as the loop prop of Menubar
    // openIndex, onOpenChange -> controlled state, same as on Menubar
  });

  // Actions
  controller.openMenu(1); // -> opens the menu and moves the tab stop to it
  controller.openMenu(1, 'hover'); // -> same, recorded as opened by hover
  controller.closeMenu();
  controller.toggleMenu(1);
  controller.setOpenIndex(1); // -> sets the index directly, null closes all menus

  // Focus actions
  controller.focusMenu(1); // -> focuses the target, switches the open menu if one is open
  controller.focusNextMenu(); // -> next enabled menu, respects loop
  controller.focusPreviousMenu();
  controller.focusFirstMenu();
  controller.focusLastMenu();
  controller.focusMenuItem(1, 'first'); // -> focuses the first item of the opened menu, call after openMenu

  // Queries
  controller.getOpenIndex(); // -> index of the opened menu, null when all menus are closed
  controller.getActiveIndex(); // -> index of the menu that holds the menubar tab stop
  controller.isMenuOpen(1); // -> boolean
  controller.getMenuCount(); // -> number of Menubar.Menu components rendered by Menubar
  controller.getEnabledIndexes(); // -> indexes of the menus that are not disabled
  controller.getOpenSource(); // -> 'click' | 'hover' | null

  return <Menubar controller={controller}>{/* menus */}</Menubar>;
}

Position

Set the position prop to change the dropdown position of all menus in the bar:

import { Menubar } from '@mantine/core';

function Demo() {
  return (
    <Menubar position="bottom-end">
      {/* ...menus */}
    </Menubar>
  );
}

To override settings of a single menu, pass Menu props to Menubar.Menu, for example position or closeOnItemClick.

Keyboard interactions

When RTL direction is set, ArrowLeft and ArrowRight are swapped.

KeyDescription
ArrowRightOn a target: move to the next top-level menu, switch the open menu if one is open. In a dropdown: open the submenu of a submenu item, otherwise open the next menu
ArrowLeftOn a target: move to the previous top-level menu, switch the open menu if one is open. In a dropdown: close the submenu, or open the previous menu from a top-level dropdown
ArrowDown / Enter / SpaceOpen the focused menu and move focus to its first item
ArrowUpOpen the focused menu and move focus to its last item
EscapeClose the open menu and return focus to its target
Home / EndMove to the first / last top-level menu, switch the open menu if one is open
Character keysMove focus to the next top-level menu that starts with the typed character
TabMove focus into or out of the menu bar (single tab stop)

Styles API

Menubar supports the Styles API; you can add styles to any inner element of the component with the classNames prop. Follow the Styles API documentation to learn more.

Component Styles API

Hover or focus a selector to highlight its elements

/*
 * Hover or focus a selector
 * to outline its elements
 */

Accessibility

Set aria-label on Menubar to give the bar an accessible name:

import { Menubar } from '@mantine/core';

function Demo() {
  return <Menubar aria-label="Application menu">{/* ...menus */}</Menubar>;
}