Skip to content

armgit / zed

Public Imported from GitHub
0

Code at the speed of thought – Zed is a high-performance, multiplayer code editor from the creators of Atom and Tree-sitter.

145 KB
Raw Blame
use crate::{
    ButtonCommon, ButtonStyle, IconButtonShape, KeyBinding, List, ListItem, ListItemSpacing,
    ListSeparator, ListSubHeader, Tooltip,
    prelude::*,
    utils::{RetainedFocusExt as _, WithRemSize},
};
use gpui::{
    Action, Anchor, AnchoredPositionMode, AnyElement, AnyView, App, Bounds, DismissEvent, Entity,
    EventEmitter, FocusHandle, Focusable, HoverListenerMode, MouseButton, MouseDownEvent,
    MouseUpEvent, Pixels, Point, Role, Size, Subscription, TaskExt, anchored, canvas, deferred,
    point, prelude::*, px, relative,
};
use menu::{SelectChild, SelectFirst, SelectLast, SelectNext, SelectParent, SelectPrevious};
use std::{
    cell::{Cell, RefCell},
    collections::HashMap,
    rc::Rc,
    time::Duration,
};
use theme::BufferLineHeight;
use web_time::Instant;

mod preview;

const CONTEXT_MENU_MIN_WIDTH: Pixels = px(200.);

#[derive(Copy, Clone, Debug, PartialEq, Eq)]
enum SubmenuOpenTrigger {
    Pointer,
    Keyboard,
}

struct OpenSubmenu {
    item_index: usize,
    entity: Entity<ContextMenu>,
    _dismiss_subscription: Subscription,
}

enum SubmenuState {
    Closed,
    Open(OpenSubmenu),
}

#[derive(Clone, Copy, PartialEq, Eq, Default)]
enum HoverTarget {
    #[default]
    None,
    MainMenu,
    Submenu,
}

pub enum ContextMenuItem {
    Separator,
    Header(SharedString),
    /// title, link_label, link_url
    HeaderWithLink(SharedString, SharedString, SharedString), // This could be folded into header
    Label(SharedString),
    Entry(ContextMenuEntry),
    CustomEntry {
        entry_render: Box<dyn Fn(&mut Window, &mut App) -> AnyElement>,
        handler: Rc<dyn Fn(Option<&FocusHandle>, &mut Window, &mut App)>,
        selectable: bool,
        documentation_aside: Option<DocumentationAside>,
    },
    EmbeddedView(AnyView),
    Submenu(ContextMenuSubmenu),
}

impl ContextMenuItem {
    pub fn custom_entry(
        entry_render: impl Fn(&mut Window, &mut App) -> AnyElement + 'static,
        handler: impl Fn(&mut Window, &mut App) + 'static,
        documentation_aside: Option<DocumentationAside>,
    ) -> Self {
        Self::CustomEntry {
            entry_render: Box::new(entry_render),
            handler: Rc::new(move |_, window, cx| handler(window, cx)),
            selectable: true,
            documentation_aside,
        }
    }
}

pub struct ContextMenuEntry {
    toggle: Option<(IconPosition, bool)>,
    label: SharedString,
    icon: Option<IconName>,
    custom_icon_path: Option<SharedString>,
    custom_icon_svg: Option<SharedString>,
    icon_position: IconPosition,
    icon_size: IconSize,
    icon_color: Option<Color>,
    handler: Rc<dyn Fn(Option<&FocusHandle>, &mut Window, &mut App)>,
    secondary_handler: Option<Rc<dyn Fn(Option<&FocusHandle>, &mut Window, &mut App)>>,
    action: Option<Box<dyn Action>>,
    disabled: bool,
    documentation_aside: Option<DocumentationAside>,
    end_slot_icon: Option<IconName>,
    end_slot_title: Option<SharedString>,
    end_slot_handler: Option<Rc<dyn Fn(Option<&FocusHandle>, &mut Window, &mut App)>>,
    show_end_slot_on_hover: bool,
}

impl ContextMenuEntry {
    pub fn new(label: impl Into<SharedString>) -> Self {
        ContextMenuEntry {
            toggle: None,
            label: label.into(),
            icon: None,
            custom_icon_path: None,
            custom_icon_svg: None,
            icon_position: IconPosition::Start,
            icon_size: IconSize::Small,
            icon_color: None,
            handler: Rc::new(|_, _, _| {}),
            secondary_handler: None,
            action: None,
            disabled: false,
            documentation_aside: None,
            end_slot_icon: None,
            end_slot_title: None,
            end_slot_handler: None,
            show_end_slot_on_hover: false,
        }
    }

    pub fn toggleable(mut self, toggle_position: IconPosition, toggled: bool) -> Self {
        self.toggle = Some((toggle_position, toggled));
        self
    }

    pub fn icon(mut self, icon: IconName) -> Self {
        self.icon = Some(icon);
        self
    }

    pub fn custom_icon_path(mut self, path: impl Into<SharedString>) -> Self {
        self.custom_icon_path = Some(path.into());
        self.custom_icon_svg = None; // Clear other icon sources if custom path is set
        self.icon = None;
        self
    }

    pub fn custom_icon_svg(mut self, svg: impl Into<SharedString>) -> Self {
        self.custom_icon_svg = Some(svg.into());
        self.custom_icon_path = None; // Clear other icon sources if custom path is set
        self.icon = None;
        self
    }

    pub fn icon_position(mut self, position: IconPosition) -> Self {
        self.icon_position = position;
        self
    }

    pub fn icon_size(mut self, icon_size: IconSize) -> Self {
        self.icon_size = icon_size;
        self
    }

    pub fn icon_color(mut self, icon_color: Color) -> Self {
        self.icon_color = Some(icon_color);
        self
    }

    pub fn toggle(mut self, toggle_position: IconPosition, toggled: bool) -> Self {
        self.toggle = Some((toggle_position, toggled));
        self
    }

    pub fn action(mut self, action: Box<dyn Action>) -> Self {
        self.action = Some(action);
        self
    }

    pub fn handler(mut self, handler: impl Fn(&mut Window, &mut App) + 'static) -> Self {
        self.handler = Rc::new(move |_, window, cx| handler(window, cx));
        self
    }

    pub fn secondary_handler(mut self, handler: impl Fn(&mut Window, &mut App) + 'static) -> Self {
        self.secondary_handler = Some(Rc::new(move |_, window, cx| handler(window, cx)));
        self
    }

    pub fn disabled(mut self, disabled: bool) -> Self {
        self.disabled = disabled;
        self
    }

    pub fn documentation_aside(
        mut self,
        side: DocumentationSide,
        render: impl Fn(&mut App) -> AnyElement + 'static,
    ) -> Self {
        self.documentation_aside = Some(DocumentationAside {
            side,
            render: Rc::new(render),
        });

        self
    }
}

impl FluentBuilder for ContextMenuEntry {}

impl From<ContextMenuEntry> for ContextMenuItem {
    fn from(entry: ContextMenuEntry) -> Self {
        ContextMenuItem::Entry(entry)
    }
}

pub struct ContextMenuSubmenu {
    id: Option<ElementId>,
    label: SharedString,
    trigger_render: Option<Box<dyn Fn(&mut Window, &mut App) -> AnyElement>>,
    icon: Option<IconName>,
    icon_color: Option<Color>,
    disabled: bool,
    builder: Rc<dyn Fn(ContextMenu, &mut Window, &mut Context<ContextMenu>) -> ContextMenu>,
}

impl ContextMenuSubmenu {
    pub fn new(
        label: impl Into<SharedString>,
        builder: impl Fn(ContextMenu, &mut Window, &mut Context<ContextMenu>) -> ContextMenu + 'static,
    ) -> Self {
        Self {
            id: None,
            label: label.into(),
            trigger_render: None,
            icon: None,
            icon_color: None,
            disabled: false,
            builder: Rc::new(builder),
        }
    }

    /// Preserves the submenu across parent rebuilds; must be unique within the parent.
    pub fn id(mut self, id: impl Into<ElementId>) -> Self {
        self.id = Some(id.into());
        self
    }

    pub fn disabled(mut self, disabled: bool) -> Self {
        self.disabled = disabled;
        self
    }

    pub fn icon(mut self, icon: IconName) -> Self {
        self.icon = Some(icon);
        self
    }

    pub fn icon_color(mut self, color: Color) -> Self {
        self.icon_color = Some(color);
        self
    }

    /// Replaces the trigger's visual content, including its icon and chevron.
    /// The label passed to [`Self::new`] remains the accessible name, and the
    /// menu retains responsibility for interaction and disabled behavior.
    /// Custom content controls its own styling, including disabled colors.
    pub fn custom_trigger(
        mut self,
        trigger_render: impl Fn(&mut Window, &mut App) -> AnyElement + 'static,
    ) -> Self {
        self.trigger_render = Some(Box::new(trigger_render));
        self
    }
}

impl FluentBuilder for ContextMenuSubmenu {}

impl From<ContextMenuSubmenu> for ContextMenuItem {
    fn from(submenu: ContextMenuSubmenu) -> Self {
        Self::Submenu(submenu)
    }
}

#[derive(RegisterComponent)]
pub struct ContextMenu {
    builder: Option<Rc<dyn Fn(Self, &mut Window, &mut Context<Self>) -> Self>>,
    items: Vec<ContextMenuItem>,
    focus_handle: FocusHandle,
    action_context: Option<FocusHandle>,
    selected_index: Option<usize>,
    delayed: bool,
    clicked: bool,
    end_slot_action: Option<Box<dyn Action>>,
    key_context: SharedString,
    _on_blur_subscription: Option<Subscription>,
    keep_open_on_confirm: bool,
    rebuild_parent_on_confirm: bool,
    fixed_width: Option<DefiniteLength>,
    spacing: ListItemSpacing,
    main_menu: Option<Entity<ContextMenu>>,
    main_menu_observed_bounds: Rc<Cell<Option<Bounds<Pixels>>>>,
    // Docs aide-related fields
    documentation_aside: Option<(usize, DocumentationAside)>,
    aside_trigger_bounds: Rc<RefCell<HashMap<usize, Bounds<Pixels>>>>,
    // Submenu-related fields
    submenu_state: SubmenuState,
    hover_target: HoverTarget,
    submenu_trigger_bounds: Rc<RefCell<HashMap<usize, Bounds<Pixels>>>>,
    submenu_bounds: Rc<Cell<Option<Bounds<Pixels>>>>,
    submenu_depth: usize,
    submenu_trigger_mouse_down: bool,
    content_focus_handle: Option<FocusHandle>,
    ignore_blur_until: Option<Instant>,
    /// When set to true, the next on_focus_in callback will not automatically
    /// select an item. This prevents a visual flash where a submenu close in
    /// on_hover(false) returns focus to the main menu and on_focus_in
    /// re-selects the first item before the next on_hover(true) clears it.
    /// Always true when accessibility support is disabled.
    suppress_focus_selection: bool,
}

#[derive(Copy, Clone, PartialEq, Eq)]
pub enum DocumentationSide {
    Left,
    Right,
}

#[derive(Clone)]
pub struct DocumentationAside {
    pub side: DocumentationSide,
    pub render: Rc<dyn Fn(&mut App) -> AnyElement>,
}

impl DocumentationAside {
    pub fn new(side: DocumentationSide, render: Rc<dyn Fn(&mut App) -> AnyElement>) -> Self {
        Self { side, render }
    }
}

impl Focusable for ContextMenu {
    fn focus_handle(&self, _cx: &App) -> FocusHandle {
        self.focus_handle.clone()
    }
}

impl EventEmitter<DismissEvent> for ContextMenu {}

impl FluentBuilder for ContextMenu {}

impl ContextMenu {
    #[inline(always)]
    pub fn new(
        window: &mut Window,
        cx: &mut Context<Self>,
        build_menu: impl FnOnce(Self, &mut Window, &mut Context<Self>) -> Self,
    ) -> Self {
        let menu = Self::new_inner(window, cx);
        build_menu(menu, window, cx)
    }

    pub fn build(
        window: &mut Window,
        cx: &mut App,
        f: impl FnOnce(Self, &mut Window, &mut Context<Self>) -> Self,
    ) -> Entity<Self> {
        cx.new(|cx| Self::new(window, cx, f))
    }

    /// Builds a [`ContextMenu`] that will stay open when making changes instead of closing after each confirmation.
    ///
    /// The main difference from [`ContextMenu::build`] is the type of the `builder`, as we need to be able to hold onto
    /// it to call it again.
    pub fn build_persistent(
        window: &mut Window,
        cx: &mut App,
        builder: impl Fn(Self, &mut Window, &mut Context<Self>) -> Self + 'static,
    ) -> Entity<Self> {
        cx.new(|cx| {
            let builder = Rc::new(builder);

            let focus_handle = cx.retained_focus_handle();
            let _on_blur_subscription = cx.on_blur(
                &focus_handle,
                window,
                |this: &mut ContextMenu, window, cx| {
                    if let Some(ignore_until) = this.ignore_blur_until {
                        if Instant::now() < ignore_until {
                            return;
                        } else {
                            this.ignore_blur_until = None;
                        }
                    }

                    if this.main_menu.is_none() {
                        if let SubmenuState::Open(open_submenu) = &this.submenu_state {
                            let submenu_focus = open_submenu.entity.read(cx).focus_handle.clone();
                            if submenu_focus.contains_focused(window, cx) {
                                return;
                            }
                        }
                    }

                    this.cancel(&menu::Cancel, window, cx)
                },
            );
            window.refresh();

            if window.is_a11y_enabled() {
                // See the note in `ContextMenu::new_inner`: select an item when the menu
                // opens so screen readers announce it instead of just "menu".
                cx.on_focus_in(&focus_handle, window, |this, window, cx| {
                    if this.selected_index.is_none() && !this.suppress_focus_selection {
                        this.select_toggled_or_first(window, cx);
                    }
                    this.suppress_focus_selection = false;
                })
                .detach();
            }

            (builder.clone())(
                Self {
                    builder: Some(builder),
                    items: Default::default(),
                    focus_handle,
                    action_context: None,
                    selected_index: None,
                    delayed: false,
                    clicked: false,
                    end_slot_action: None,
                    key_context: "menu".into(),
                    _on_blur_subscription: Some(_on_blur_subscription),
                    keep_open_on_confirm: true,
                    rebuild_parent_on_confirm: false,
                    fixed_width: None,
                    spacing: ListItemSpacing::default(),
                    main_menu: None,
                    main_menu_observed_bounds: Rc::new(Cell::new(None)),
                    documentation_aside: None,
                    aside_trigger_bounds: Rc::new(RefCell::new(HashMap::default())),
                    submenu_state: SubmenuState::Closed,
                    hover_target: HoverTarget::MainMenu,
                    submenu_trigger_bounds: Rc::new(RefCell::new(HashMap::default())),
                    submenu_bounds: Rc::new(Cell::new(None)),
                    submenu_depth: 0,
                    submenu_trigger_mouse_down: false,
                    content_focus_handle: None,
                    ignore_blur_until: None,
                    suppress_focus_selection: !window.is_a11y_enabled(),
                },
                window,
                cx,
            )
        })
    }

    /// Rebuilds persistent menus and submenus, preserving open submenus by ID.
    /// No-op without a retained builder.
    pub fn rebuild(&mut self, window: &mut Window, cx: &mut Context<Self>) {
        let Some(builder) = self.builder.clone() else {
            return;
        };

        let new_menu = (builder.clone())(
            Self {
                builder: Some(builder),
                items: Default::default(),
                focus_handle: self.focus_handle.clone(),
                action_context: None,
                selected_index: None,
                delayed: false,
                clicked: false,
                end_slot_action: None,
                key_context: "menu".into(),
                _on_blur_subscription: None,
                keep_open_on_confirm: self.keep_open_on_confirm,
                rebuild_parent_on_confirm: self.rebuild_parent_on_confirm,
                fixed_width: None,
                spacing: self.spacing,
                main_menu: self.main_menu.clone(),
                main_menu_observed_bounds: Rc::new(Cell::new(None)),
                documentation_aside: None,
                aside_trigger_bounds: Rc::new(RefCell::new(HashMap::default())),
                submenu_state: SubmenuState::Closed,
                hover_target: HoverTarget::MainMenu,
                submenu_trigger_bounds: Rc::new(RefCell::new(HashMap::default())),
                submenu_bounds: Rc::new(Cell::new(None)),
                submenu_depth: self.submenu_depth,
                submenu_trigger_mouse_down: false,
                content_focus_handle: None,
                ignore_blur_until: None,
                suppress_focus_selection: !window.is_a11y_enabled(),
            },
            window,
            cx,
        );

        let open_submenu = match &self.submenu_state {
            SubmenuState::Open(open) => {
                let id = match self.items.get(open.item_index) {
                    Some(ContextMenuItem::Submenu(submenu)) => submenu.id.as_ref(),
                    _ => None,
                };
                let replacement = id.and_then(|id| {
                    new_menu
                        .items
                        .iter()
                        .enumerate()
                        .find_map(|(index, item)| match item {
                            ContextMenuItem::Submenu(submenu)
                                if submenu.id.as_ref() == Some(id) =>
                            {
                                Some((index, submenu.disabled, submenu.builder.clone()))
                            }
                            _ => None,
                        })
                });
                Some((open.item_index, open.entity.clone(), replacement))
            }
            SubmenuState::Closed => None,
        };

        self.items = new_menu.items;
        self.action_context = new_menu.action_context;
        self.end_slot_action = new_menu.end_slot_action;
        self.key_context = new_menu.key_context;
        self.keep_open_on_confirm = new_menu.keep_open_on_confirm;
        self.rebuild_parent_on_confirm = new_menu.rebuild_parent_on_confirm;
        self.fixed_width = new_menu.fixed_width;
        self.spacing = new_menu.spacing;
        self.documentation_aside = None;
        self.aside_trigger_bounds.borrow_mut().clear();
        self.content_focus_handle = new_menu.content_focus_handle;

        let selected_index = self.selected_index.take();
        if let Some(index) = selected_index {
            self.select_nearest(index, window, cx);
        }

        if let Some((old_index, submenu, replacement)) = open_submenu {
            let trigger_index = replacement
                .as_ref()
                .map_or(old_index, |(index, _, _)| *index);
            if let Some((index, false, builder)) = replacement {
                if let SubmenuState::Open(open) = &mut self.submenu_state {
                    open.item_index = index;
                }
                if selected_index == Some(old_index) {
                    self.select_index(index, window, cx);
                }
                let bounds = self.submenu_trigger_bounds.borrow_mut().remove(&old_index);
                self.submenu_trigger_bounds.borrow_mut().clear();
                if let Some(bounds) = bounds {
                    self.submenu_trigger_bounds
                        .borrow_mut()
                        .insert(index, bounds);
                }
                submenu.update(cx, |submenu, cx| {
                    submenu.builder = Some(builder);
                    submenu.rebuild(window, cx);
                });
            } else {
                self.close_submenu(false, cx);
                self.select_nearest(trigger_index, window, cx);
                window.focus(&self.focus_handle, cx);
                self.submenu_trigger_bounds.borrow_mut().clear();
            }
        } else {
            self.submenu_trigger_bounds.borrow_mut().clear();
        }

        if self.main_menu.is_some() && !self.items.iter().any(ContextMenuItem::is_selectable) {
            // The parent may still be inside rebuild.
            cx.defer_in(window, |this, window, cx| {
                if !this.items.iter().any(ContextMenuItem::is_selectable) {
                    this.select_submenu_parent(&SelectParent, window, cx);
                }
            });
        }

        cx.notify();
    }

    pub fn context(mut self, focus: FocusHandle) -> Self {
        self.action_context = Some(focus);
        self
    }

    pub fn header(mut self, title: impl Into<SharedString>) -> Self {
        self.items.push(ContextMenuItem::Header(title.into()));
        self
    }

    pub fn header_with_link(
        mut self,
        title: impl Into<SharedString>,
        link_label: impl Into<SharedString>,
        link_url: impl Into<SharedString>,
    ) -> Self {
        self.items.push(ContextMenuItem::HeaderWithLink(
            title.into(),
            link_label.into(),
            link_url.into(),
        ));
        self
    }

    pub fn separator(mut self) -> Self {
        self.items.push(ContextMenuItem::Separator);
        self
    }

    pub fn extend<I: Into<ContextMenuItem>>(mut self, items: impl IntoIterator<Item = I>) -> Self {
        self.items.extend(items.into_iter().map(Into::into));
        self
    }

    pub fn item(mut self, item: impl Into<ContextMenuItem>) -> Self {
        self.items.push(item.into());
        self
    }

    pub fn push_item(&mut self, item: impl Into<ContextMenuItem>) {
        self.items.push(item.into());
    }

    pub fn entry(
        mut self,
        label: impl Into<SharedString>,
        action: Option<Box<dyn Action>>,
        handler: impl Fn(&mut Window, &mut App) + 'static,
    ) -> Self {
        self.items.push(ContextMenuItem::Entry(ContextMenuEntry {
            toggle: None,
            label: label.into(),
            handler: Rc::new(move |_, window, cx| handler(window, cx)),
            secondary_handler: None,
            icon: None,
            custom_icon_path: None,
            custom_icon_svg: None,
            icon_position: IconPosition::End,
            icon_size: IconSize::Small,
            icon_color: None,
            action,
            disabled: false,
            documentation_aside: None,
            end_slot_icon: None,
            end_slot_title: None,
            end_slot_handler: None,
            show_end_slot_on_hover: false,
        }));
        self
    }

    pub fn entry_with_end_slot(
        mut self,
        label: impl Into<SharedString>,
        action: Option<Box<dyn Action>>,
        handler: impl Fn(&mut Window, &mut App) + 'static,
        end_slot_icon: IconName,
        end_slot_title: SharedString,
        end_slot_handler: impl Fn(&mut Window, &mut App) + 'static,
    ) -> Self {
        self.items.push(ContextMenuItem::Entry(ContextMenuEntry {
            toggle: None,
            label: label.into(),
            handler: Rc::new(move |_, window, cx| handler(window, cx)),
            secondary_handler: None,
            icon: None,
            custom_icon_path: None,
            custom_icon_svg: None,
            icon_position: IconPosition::End,
            icon_size: IconSize::Small,
            icon_color: None,
            action,
            disabled: false,
            documentation_aside: None,
            end_slot_icon: Some(end_slot_icon),
            end_slot_title: Some(end_slot_title),
            end_slot_handler: Some(Rc::new(move |_, window, cx| end_slot_handler(window, cx))),
            show_end_slot_on_hover: false,
        }));
        self
    }

    pub fn entry_with_end_slot_on_hover(
        mut self,
        label: impl Into<SharedString>,
        action: Option<Box<dyn Action>>,
        handler: impl Fn(&mut Window, &mut App) + 'static,
        end_slot_icon: IconName,
        end_slot_title: SharedString,
        end_slot_handler: impl Fn(&mut Window, &mut App) + 'static,
    ) -> Self {
        self.items.push(ContextMenuItem::Entry(ContextMenuEntry {
            toggle: None,
            label: label.into(),
            handler: Rc::new(move |_, window, cx| handler(window, cx)),
            secondary_handler: None,
            icon: None,
            custom_icon_path: None,
            custom_icon_svg: None,
            icon_position: IconPosition::End,
            icon_size: IconSize::Small,
            icon_color: None,
            action,
            disabled: false,
            documentation_aside: None,
            end_slot_icon: Some(end_slot_icon),
            end_slot_title: Some(end_slot_title),
            end_slot_handler: Some(Rc::new(move |_, window, cx| end_slot_handler(window, cx))),
            show_end_slot_on_hover: true,
        }));
        self
    }

    pub fn toggleable_entry(
        self,
        label: impl Into<SharedString>,
        toggled: bool,
        position: IconPosition,
        action: Option<Box<dyn Action>>,
        handler: impl Fn(&mut Window, &mut App) + 'static,
    ) -> Self {
        self.toggleable_entry_disabled_when(label, toggled, false, position, action, handler)
    }

    /// Like [`Self::toggleable_entry`], but the entry is rendered disabled (and its handler is not
    /// invoked) when `disabled` is `true`.
    pub fn toggleable_entry_disabled_when(
        mut self,
        label: impl Into<SharedString>,
        toggled: bool,
        disabled: bool,
        position: IconPosition,
        action: Option<Box<dyn Action>>,
        handler: impl Fn(&mut Window, &mut App) + 'static,
    ) -> Self {
        self.items.push(ContextMenuItem::Entry(ContextMenuEntry {
            toggle: Some((position, toggled)),
            label: label.into(),
            handler: Rc::new(move |_, window, cx| handler(window, cx)),
            secondary_handler: None,
            icon: None,
            custom_icon_path: None,
            custom_icon_svg: None,
            icon_position: position,
            icon_size: IconSize::Small,
            icon_color: None,
            action,
            disabled,
            documentation_aside: None,
            end_slot_icon: None,
            end_slot_title: None,
            end_slot_handler: None,
            show_end_slot_on_hover: false,
        }));
        self
    }

    pub fn custom_row(
        mut self,
        entry_render: impl Fn(&mut Window, &mut App) -> AnyElement + 'static,
    ) -> Self {
        self.items.push(ContextMenuItem::CustomEntry {
            entry_render: Box::new(entry_render),
            handler: Rc::new(|_, _, _| {}),
            selectable: false,
            documentation_aside: None,
        });
        self
    }

    pub fn custom_entry(
        mut self,
        entry_render: impl Fn(&mut Window, &mut App) -> AnyElement + 'static,
        handler: impl Fn(&mut Window, &mut App) + 'static,
    ) -> Self {
        self.items.push(ContextMenuItem::CustomEntry {
            entry_render: Box::new(entry_render),
            handler: Rc::new(move |_, window, cx| handler(window, cx)),
            selectable: true,
            documentation_aside: None,
        });
        self
    }

    pub fn custom_entry_with_docs(
        mut self,
        entry_render: impl Fn(&mut Window, &mut App) -> AnyElement + 'static,
        handler: impl Fn(&mut Window, &mut App) + 'static,
        documentation_aside: Option<DocumentationAside>,
    ) -> Self {
        self.items.push(ContextMenuItem::CustomEntry {
            entry_render: Box::new(entry_render),
            handler: Rc::new(move |_, window, cx| handler(window, cx)),
            selectable: true,
            documentation_aside,
        });
        self
    }

    pub fn selectable(mut self, selectable: bool) -> Self {
        if let Some(ContextMenuItem::CustomEntry {
            selectable: entry_selectable,
            ..
        }) = self.items.last_mut()
        {
            *entry_selectable = selectable;
        }
        self
    }

    pub fn label(mut self, label: impl Into<SharedString>) -> Self {
        self.items.push(ContextMenuItem::Label(label.into()));
        self
    }

    pub fn action(self, label: impl Into<SharedString>, action: Box<dyn Action>) -> Self {
        self.action_checked(label, action, false)
    }

    pub fn action_checked(
        self,
        label: impl Into<SharedString>,
        action: Box<dyn Action>,
        checked: bool,
    ) -> Self {
        self.action_checked_with_disabled(label, action, checked, false)
    }

    pub fn action_checked_with_disabled(
        mut self,
        label: impl Into<SharedString>,
        action: Box<dyn Action>,
        checked: bool,
        disabled: bool,
    ) -> Self {
        self.items.push(ContextMenuItem::Entry(ContextMenuEntry {
            toggle: if checked {
                Some((IconPosition::Start, true))
            } else {
                None
            },
            label: label.into(),
            action: Some(action.boxed_clone()),
            handler: Rc::new(move |context, window, cx| {
                if let Some(context) = &context {
                    window.focus(context, cx);
                }
                window.dispatch_action(action.boxed_clone(), cx);
            }),
            secondary_handler: None,
            icon: None,
            custom_icon_path: None,
            custom_icon_svg: None,
            icon_position: IconPosition::End,
            icon_size: IconSize::Small,
            icon_color: None,
            disabled,
            documentation_aside: None,
            end_slot_icon: None,
            end_slot_title: None,
            end_slot_handler: None,
            show_end_slot_on_hover: false,
        }));
        self
    }

    pub fn action_disabled_when(
        mut self,
        disabled: bool,
        label: impl Into<SharedString>,
        action: Box<dyn Action>,
    ) -> Self {
        self.items.push(ContextMenuItem::Entry(ContextMenuEntry {
            toggle: None,
            label: label.into(),
            action: Some(action.boxed_clone()),
            handler: Rc::new(move |context, window, cx| {
                if let Some(context) = &context {
                    window.focus(context, cx);
                }
                window.dispatch_action(action.boxed_clone(), cx);
            }),
            secondary_handler: None,
            icon: None,
            custom_icon_path: None,
            custom_icon_svg: None,
            icon_size: IconSize::Small,
            icon_position: IconPosition::End,
            icon_color: None,
            disabled,
            documentation_aside: None,
            end_slot_icon: None,
            end_slot_title: None,
            end_slot_handler: None,
            show_end_slot_on_hover: false,
        }));
        self
    }

    pub fn link(self, label: impl Into<SharedString>, action: Box<dyn Action>) -> Self {
        self.link_with_handler(label, action, |_, _| {})
    }

    pub fn link_with_handler(
        mut self,
        label: impl Into<SharedString>,
        action: Box<dyn Action>,
        handler: impl Fn(&mut Window, &mut App) + 'static,
    ) -> Self {
        self.items.push(ContextMenuItem::Entry(ContextMenuEntry {
            toggle: None,
            label: label.into(),
            action: Some(action.boxed_clone()),
            handler: Rc::new(move |_, window, cx| {
                handler(window, cx);
                window.dispatch_action(action.boxed_clone(), cx);
            }),
            secondary_handler: None,
            icon: Some(IconName::ArrowUpRight),
            custom_icon_path: None,
            custom_icon_svg: None,
            icon_size: IconSize::XSmall,
            icon_position: IconPosition::End,
            icon_color: None,
            disabled: false,
            documentation_aside: None,
            end_slot_icon: None,
            end_slot_title: None,
            end_slot_handler: None,
            show_end_slot_on_hover: false,
        }));
        self
    }

    pub fn submenu(
        self,
        label: impl Into<SharedString>,
        builder: impl Fn(ContextMenu, &mut Window, &mut Context<ContextMenu>) -> ContextMenu + 'static,
    ) -> Self {
        self.item(ContextMenuSubmenu::new(label, builder))
    }

    pub fn submenu_with_icon(
        self,
        label: impl Into<SharedString>,
        icon: IconName,
        builder: impl Fn(ContextMenu, &mut Window, &mut Context<ContextMenu>) -> ContextMenu + 'static,
    ) -> Self {
        self.item(ContextMenuSubmenu::new(label, builder).icon(icon))
    }

    pub fn submenu_with_colored_icon(
        self,
        label: impl Into<SharedString>,
        icon: IconName,
        icon_color: Color,
        builder: impl Fn(ContextMenu, &mut Window, &mut Context<ContextMenu>) -> ContextMenu + 'static,
    ) -> Self {
        self.item(
            ContextMenuSubmenu::new(label, builder)
                .icon(icon)
                .icon_color(icon_color),
        )
    }

    /// Submenus must opt in separately.
    pub fn keep_open_on_confirm(mut self, keep_open: bool) -> Self {
        self.keep_open_on_confirm = keep_open;
        self
    }

    /// Requires keep-open confirmation, a rebuildable parent, and a [`ContextMenuSubmenu::id`].
    pub fn rebuild_parent_on_confirm(mut self, rebuild: bool) -> Self {
        self.rebuild_parent_on_confirm = rebuild;
        self
    }

    pub fn trigger_end_slot_handler(&mut self, window: &mut Window, cx: &mut Context<Self>) {
        let Some(entry) = self.selected_index.and_then(|ix| self.items.get(ix)) else {
            return;
        };
        let ContextMenuItem::Entry(entry) = entry else {
            return;
        };
        let Some(handler) = entry.end_slot_handler.as_ref() else {
            return;
        };
        handler(None, window, cx);
    }

    pub fn embedded_view(mut self, view: impl Into<AnyView>) -> Self {
        self.items.push(ContextMenuItem::EmbeddedView(view.into()));
        self
    }

    /// Focuses this handle instead of the menu when it opens as a submenu.
    /// The handle must be tracked by an element inside the menu.
    pub fn focus_content(mut self, focus_handle: FocusHandle) -> Self {
        self.content_focus_handle = Some(focus_handle);
        self
    }

    fn submenu_focus_target(&self) -> FocusHandle {
        self.content_focus_handle
            .clone()
            .unwrap_or_else(|| self.focus_handle.clone())
    }

    pub fn fixed_width(mut self, width: DefiniteLength) -> Self {
        self.fixed_width = Some(width);
        self
    }

    pub fn spacing(mut self, spacing: ListItemSpacing) -> Self {
        self.spacing = spacing;
        self
    }

    pub fn end_slot_action(mut self, action: Box<dyn Action>) -> Self {
        self.end_slot_action = Some(action);
        self
    }

    pub fn key_context(mut self, context: impl Into<SharedString>) -> Self {
        self.key_context = context.into();
        self
    }

    pub fn selected_index(&self) -> Option<usize> {
        self.selected_index
    }

    pub fn confirm(&mut self, _: &menu::Confirm, window: &mut Window, cx: &mut Context<Self>) {
        let Some(ix) = self.selected_index else {
            return cx.emit(DismissEvent);
        };

        if let Some(ContextMenuItem::Submenu(submenu)) = self.items.get(ix) {
            if submenu.disabled {
                return;
            }
            self.open_submenu(
                ix,
                submenu.builder.clone(),
                SubmenuOpenTrigger::Keyboard,
                window,
                cx,
            );

            if let SubmenuState::Open(open_submenu) = &self.submenu_state {
                let focus_target = open_submenu.entity.read(cx).submenu_focus_target();
                window.focus(&focus_target, cx);
                open_submenu.entity.update(cx, |submenu, cx| {
                    submenu.select_first(&SelectFirst, window, cx);
                });
            }

            cx.notify();
            return;
        }

        let context = self.action_context.as_ref();

        if let Some(
            ContextMenuItem::Entry(ContextMenuEntry {
                handler,
                disabled: false,
                ..
            })
            | ContextMenuItem::CustomEntry { handler, .. },
        ) = self.items.get(ix)
        {
            (handler)(context, window, cx)
        }

        self.finish_confirm(window, cx);
    }

    pub fn secondary_confirm(
        &mut self,
        _: &menu::SecondaryConfirm,
        window: &mut Window,
        cx: &mut Context<Self>,
    ) {
        let Some(ix) = self.selected_index else {
            return;
        };

        if let Some(ContextMenuItem::Submenu(submenu)) = self.items.get(ix) {
            if submenu.disabled {
                return;
            }
            self.open_submenu(
                ix,
                submenu.builder.clone(),
                SubmenuOpenTrigger::Keyboard,
                window,
                cx,
            );

            if let SubmenuState::Open(open_submenu) = &self.submenu_state {
                let focus_target = open_submenu.entity.read(cx).submenu_focus_target();
                window.focus(&focus_target, cx);
                open_submenu.entity.update(cx, |submenu, cx| {
                    submenu.select_first(&SelectFirst, window, cx);
                });
            }

            cx.notify();
            return;
        }

        let context = self.action_context.as_ref();

        if let Some(ContextMenuItem::Entry(ContextMenuEntry {
            handler,
            secondary_handler,
            disabled: false,
            ..
        })) = self.items.get(ix)
        {
            if let Some(secondary) = secondary_handler {
                (secondary)(context, window, cx)
            } else {
                (handler)(context, window, cx)
            }
        } else if let Some(ContextMenuItem::CustomEntry { handler, .. }) = self.items.get(ix) {
            (handler)(context, window, cx)
        }

        self.finish_confirm(window, cx);
    }

    fn finish_confirm(&mut self, window: &mut Window, cx: &mut Context<Self>) {
        self.clicked = !self.keep_open_on_confirm;
        if !self.keep_open_on_confirm {
            cx.emit(DismissEvent);
            return;
        }

        if self.rebuild_parent_on_confirm {
            if let Some(parent) = self
                .main_menu
                .as_ref()
                .filter(|parent| parent.read(cx).builder.is_some())
            {
                let parent = parent.downgrade();
                let entity_id = cx.entity_id();
                // Avoid re-entering this submenu through the parent's rebuild.
                window.defer(cx, move |window, cx| {
                    if let Some(parent) = parent.upgrade() {
                        parent.update(cx, |parent, cx| {
                            if matches!(&parent.submenu_state, SubmenuState::Open(open) if open.entity.entity_id() == entity_id) {
                                parent.rebuild(window, cx);
                            }
                        });
                    }
                });
                return;
            }
        }

        self.rebuild(window, cx);
    }

    pub fn cancel(&mut self, _: &menu::Cancel, window: &mut Window, cx: &mut Context<Self>) {
        if self.main_menu.is_some() {
            cx.emit(DismissEvent);

            // Restore keyboard focus to the parent menu so arrow keys / Escape / Enter work again.
            if let Some(parent) = &self.main_menu {
                let parent_focus = parent.read(cx).focus_handle.clone();

                parent.update(cx, |parent, _cx| {
                    parent.ignore_blur_until = Some(Instant::now() + Duration::from_millis(200));
                });

                window.focus(&parent_focus, cx);
            }

            return;
        }

        cx.emit(DismissEvent);
    }

    pub fn end_slot(&mut self, _: &dyn Action, window: &mut Window, cx: &mut Context<Self>) {
        let Some(item) = self.selected_index.and_then(|ix| self.items.get(ix)) else {
            return;
        };
        let ContextMenuItem::Entry(entry) = item else {
            return;
        };
        let Some(handler) = entry.end_slot_handler.as_ref() else {
            return;
        };
        handler(None, window, cx);
        self.rebuild(window, cx);
        cx.notify();
    }

    pub fn clear_selected(&mut self) {
        self.selected_index = None;
    }

    pub fn select_first(&mut self, _: &SelectFirst, window: &mut Window, cx: &mut Context<Self>) {
        if let Some(ix) = self.items.iter().position(|item| item.is_selectable()) {
            self.select_index(ix, window, cx);
        }
        cx.notify();
    }

    /// Selects the currently-checked entry if one exists (e.g. the active value
    /// in a single-select dropdown), otherwise the first selectable item.
    ///
    /// This is intended to be called when the menu opens. Per the ARIA menu
    /// button pattern, opening a menu should place focus on a menu item rather
    /// than the menu container, so that assistive technology immediately
    /// announces a meaningful item (ideally the current selection) instead of
    /// just "menu".
    pub fn select_toggled_or_first(&mut self, window: &mut Window, cx: &mut Context<Self>) {
        let toggled_ix = self.items.iter().position(|item| {
            matches!(
                item,
                ContextMenuItem::Entry(ContextMenuEntry {
                    toggle: Some((_, true)),
                    ..
                })
            )
        });
        if let Some(ix) = toggled_ix {
            self.select_index(ix, window, cx);
            cx.notify();
        } else {
            self.select_first(&SelectFirst, window, cx);
        }
    }

    pub fn select_last(&mut self, window: &mut Window, cx: &mut Context<Self>) -> Option<usize> {
        for (ix, item) in self.items.iter().enumerate().rev() {
            if item.is_selectable() {
                return self.select_index(ix, window, cx);
            }
        }
        None
    }

    fn handle_select_last(&mut self, _: &SelectLast, window: &mut Window, cx: &mut Context<Self>) {
        if self.select_last(window, cx).is_some() {
            cx.notify();
        }
    }

    pub fn select_next(&mut self, _: &SelectNext, window: &mut Window, cx: &mut Context<Self>) {
        if let Some(ix) = self.selected_index {
            let next_index = ix + 1;
            if self.items.len() <= next_index {
                self.select_first(&SelectFirst, window, cx);
                return;
            } else {
                for (ix, item) in self.items.iter().enumerate().skip(next_index) {
                    if item.is_selectable() {
                        self.select_index(ix, window, cx);
                        cx.notify();
                        return;
                    }
                }
            }
        }
        self.select_first(&SelectFirst, window, cx);
    }

    pub fn select_previous(
        &mut self,
        _: &SelectPrevious,
        window: &mut Window,
        cx: &mut Context<Self>,
    ) {
        if let Some(ix) = self.selected_index {
            for (ix, item) in self.items.iter().enumerate().take(ix).rev() {
                if item.is_selectable() {
                    self.select_index(ix, window, cx);
                    cx.notify();
                    return;
                }
            }
        }
        self.handle_select_last(&SelectLast, window, cx);
    }

    pub fn select_submenu_child(
        &mut self,
        _: &SelectChild,
        window: &mut Window,
        cx: &mut Context<Self>,
    ) {
        let Some(ix) = self.selected_index else {
            return;
        };

        let Some(ContextMenuItem::Submenu(submenu)) = self.items.get(ix) else {
            return;
        };
        if submenu.disabled {
            return;
        }

        self.open_submenu(
            ix,
            submenu.builder.clone(),
            SubmenuOpenTrigger::Keyboard,
            window,
            cx,
        );

        if let SubmenuState::Open(open_submenu) = &self.submenu_state {
            let focus_target = open_submenu.entity.read(cx).submenu_focus_target();
            window.focus(&focus_target, cx);
            open_submenu.entity.update(cx, |submenu, cx| {
                submenu.select_first(&SelectFirst, window, cx);
            });
        }

        cx.notify();
    }

    pub fn select_submenu_parent(
        &mut self,
        _: &SelectParent,
        window: &mut Window,
        cx: &mut Context<Self>,
    ) {
        if let Some(parent) = &self.main_menu {
            let entity_id = cx.entity_id();
            parent.update(cx, |parent, cx| {
                let SubmenuState::Open(open) = &parent.submenu_state else {
                    return;
                };
                if open.entity.entity_id() != entity_id {
                    return;
                }
                let trigger_index = open.item_index;
                parent.close_submenu(false, cx);
                parent.select_nearest(trigger_index, window, cx);
                window.focus(&parent.focus_handle, cx);
            });
            cx.emit(DismissEvent);
        }
    }

    fn select_nearest(&mut self, index: usize, window: &mut Window, cx: &mut Context<Self>) {
        self.selected_index = None;
        self.documentation_aside = None;
        if let Some(index) = self
            .items
            .iter()
            .enumerate()
            .filter(|(_, item)| item.is_selectable())
            .min_by_key(|(candidate, _)| candidate.abs_diff(index))
            .map(|(index, _)| index)
        {
            self.select_index(index, window, cx);
        }
    }

    fn select_index(
        &mut self,
        ix: usize,
        _window: &mut Window,
        _cx: &mut Context<Self>,
    ) -> Option<usize> {
        self.documentation_aside = None;
        let item = self.items.get(ix)?;
        if item.is_selectable() {
            self.selected_index = Some(ix);
            match item {
                ContextMenuItem::Entry(entry) => {
                    if let Some(callback) = &entry.documentation_aside {
                        self.documentation_aside = Some((ix, callback.clone()));
                    }
                }
                ContextMenuItem::CustomEntry {
                    documentation_aside: Some(callback),
                    ..
                } => {
                    self.documentation_aside = Some((ix, callback.clone()));
                }
                ContextMenuItem::Submenu(_) => {}
                _ => (),
            }
        }
        Some(ix)
    }

    fn create_submenu(
        builder: Rc<dyn Fn(ContextMenu, &mut Window, &mut Context<ContextMenu>) -> ContextMenu>,
        parent_entity: Entity<ContextMenu>,
        parent_depth: usize,
        window: &mut Window,
        cx: &mut Context<Self>,
    ) -> (Entity<ContextMenu>, Subscription) {
        let submenu = Self::build_submenu(builder, parent_entity, parent_depth, window, cx);

        let dismiss_subscription = cx.subscribe(&submenu, |this, submenu, _: &DismissEvent, cx| {
            let should_dismiss_parent = submenu.read(cx).clicked;

            this.close_submenu(false, cx);

            if should_dismiss_parent {
                cx.emit(DismissEvent);
            }
        });

        (submenu, dismiss_subscription)
    }

    fn build_submenu(
        builder: Rc<dyn Fn(ContextMenu, &mut Window, &mut Context<ContextMenu>) -> ContextMenu>,
        parent_entity: Entity<ContextMenu>,
        parent_depth: usize,
        window: &mut Window,
        cx: &mut App,
    ) -> Entity<ContextMenu> {
        cx.new(|cx| {
            let focus_handle = cx.retained_focus_handle();

            let _on_blur_subscription = cx.on_blur(
                &focus_handle,
                window,
                |_this: &mut ContextMenu, _window, _cx| {},
            );

            let mut menu = ContextMenu {
                builder: Some(builder.clone()),
                items: Default::default(),
                focus_handle,
                action_context: None,
                selected_index: None,
                delayed: false,
                clicked: false,
                end_slot_action: None,
                key_context: "menu".into(),
                _on_blur_subscription: Some(_on_blur_subscription),
                keep_open_on_confirm: false,
                rebuild_parent_on_confirm: false,
                fixed_width: None,
                spacing: ListItemSpacing::default(),
                documentation_aside: None,
                aside_trigger_bounds: Rc::new(RefCell::new(HashMap::default())),
                main_menu: Some(parent_entity),
                main_menu_observed_bounds: Rc::new(Cell::new(None)),
                submenu_state: SubmenuState::Closed,
                hover_target: HoverTarget::MainMenu,
                submenu_trigger_bounds: Rc::new(RefCell::new(HashMap::default())),
                submenu_bounds: Rc::new(Cell::new(None)),
                submenu_depth: parent_depth + 1,
                submenu_trigger_mouse_down: false,
                content_focus_handle: None,
                ignore_blur_until: None,
                suppress_focus_selection: !window.is_a11y_enabled(),
            };

            menu = (builder)(menu, window, cx);
            menu
        })
    }

    fn close_submenu(&mut self, clear_selection: bool, cx: &mut Context<Self>) {
        self.submenu_state = SubmenuState::Closed;
        self.hover_target = HoverTarget::MainMenu;
        self.submenu_bounds.set(None);

        if clear_selection {
            self.selected_index = None;
        }

        cx.notify();
    }

    fn open_submenu(
        &mut self,
        item_index: usize,
        builder: Rc<dyn Fn(ContextMenu, &mut Window, &mut Context<ContextMenu>) -> ContextMenu>,
        reason: SubmenuOpenTrigger,
        window: &mut Window,
        cx: &mut Context<Self>,
    ) {
        // If the submenu is already open for this item, don't recreate it.
        if matches!(
            &self.submenu_state,
            SubmenuState::Open(open_submenu) if open_submenu.item_index == item_index
        ) {
            return;
        }

        let (submenu, dismiss_subscription) =
            Self::create_submenu(builder, cx.entity(), self.submenu_depth, window, cx);

        self.submenu_bounds.set(None);
        self.hover_target = HoverTarget::MainMenu;

        // When opening a submenu via keyboard, there is a brief moment where focus/hover can
        // transition in a way that triggers the parent menu's `on_blur` dismissal.
        if matches!(reason, SubmenuOpenTrigger::Keyboard) {
            self.ignore_blur_until = Some(Instant::now() + Duration::from_millis(150));
        }

        self.submenu_state = SubmenuState::Open(OpenSubmenu {
            item_index,
            entity: submenu,
            _dismiss_subscription: dismiss_subscription,
        });

        cx.notify();
    }

    pub fn on_action_dispatch(
        &mut self,
        dispatched: &dyn Action,
        window: &mut Window,
        cx: &mut Context<Self>,
    ) {
        if self.clicked {
            cx.propagate();
            return;
        }

        if let Some(ix) = self.items.iter().position(|item| {
            if let ContextMenuItem::Entry(ContextMenuEntry {
                action: Some(action),
                disabled: false,
                ..
            }) = item
            {
                action.partial_eq(dispatched)
            } else {
                false
            }
        }) {
            self.select_index(ix, window, cx);
            self.delayed = true;
            cx.notify();
            let action = dispatched.boxed_clone();
            cx.spawn_in(window, async move |this, cx| {
                cx.background_executor()
                    .timer(Duration::from_millis(50))
                    .await;
                cx.update(|window, cx| {
                    this.update(cx, |this, cx| {
                        this.cancel(&menu::Cancel, window, cx);
                        window.dispatch_action(action, cx);
                    })
                })
            })
            .detach_and_log_err(cx);
        } else {
            cx.propagate()
        }
    }

    pub fn on_blur_subscription(mut self, new_subscription: Subscription) -> Self {
        self._on_blur_subscription = Some(new_subscription);
        self
    }

    fn render_menu_item(
        &self,
        ix: usize,
        item: &ContextMenuItem,
        window: &mut Window,
        cx: &mut Context<Self>,
    ) -> impl IntoElement + use<> {
        // The menu keeps real focus on its container, so for assistive
        // technology to track the selected item we report it as the active
        // descendant. GPUI only honors this while the menu actually holds
        // focus, so we mark the selected item unconditionally here.
        let is_active_descendant = |selectable: bool| selectable && Some(ix) == self.selected_index;
        match item {
            ContextMenuItem::Separator => ListSeparator.into_any_element(),
            ContextMenuItem::EmbeddedView(view) => view.clone().into_any_element(),
            ContextMenuItem::Header(header) => ListSubHeader::new(header.clone())
                .inset(true)
                .into_any_element(),
            ContextMenuItem::HeaderWithLink(header, label, url) => {
                let url = url.clone();
                let link_id = ElementId::Name(format!("link-{}", url).into());
                ListSubHeader::new(header.clone())
                    .inset(true)
                    .end_slot(
                        Button::new(link_id, label.clone())
                            .color(Color::Muted)
                            .label_size(LabelSize::Small)
                            .size(ButtonSize::None)
                            .style(ButtonStyle::Transparent)
                            .on_click(move |_, _, cx| {
                                let url = url.clone();
                                cx.open_url(&url);
                            })
                            .into_any_element(),
                    )
                    .into_any_element()
            }
            ContextMenuItem::Label(label) => ListItem::new(ix)
                .inset(true)
                .spacing(self.spacing)
                .disabled(true)
                .child(Label::new(label.clone()))
                .into_any_element(),
            ContextMenuItem::Entry(entry) => self
                .render_menu_entry(ix, entry, is_active_descendant(true), window, cx)
                .into_any_element(),
            ContextMenuItem::CustomEntry {
                entry_render,
                handler,
                selectable,
                documentation_aside,
                ..
            } => {
                let handler = handler.clone();
                let menu = cx.entity().downgrade();
                let selectable = *selectable;
                let aside_trigger_bounds = self.aside_trigger_bounds.clone();

                div()
                    .id(("context-menu-child", ix))
                    .when_some(documentation_aside.clone(), |this, documentation_aside| {
                        this.occlude()
                            .on_hover(cx.listener(move |menu, hovered, _, cx| {
                            if *hovered {
                                menu.documentation_aside = Some((ix, documentation_aside.clone()));
                            } else if matches!(menu.documentation_aside, Some((id, _)) if id == ix)
                            {
                                menu.documentation_aside = None;
                            }
                            cx.notify();
                        }))
                    })
                    .when(documentation_aside.is_some(), |this| {
                        this.child(
                            canvas(
                                {
                                    let aside_trigger_bounds = aside_trigger_bounds.clone();
                                    move |bounds, _window, _cx| {
                                        aside_trigger_bounds.borrow_mut().insert(ix, bounds);
                                    }
                                },
                                |_bounds, _state, _window, _cx| {},
                            )
                            .size_full()
                            .absolute()
                            .top_0()
                            .left_0(),
                        )
                    })
                    .child(
                        ListItem::new(ix)
                            .inset(true)
                            .spacing(self.spacing)
                            .when(selectable, |item| item.aria_role(Role::MenuItem))
                            .when(is_active_descendant(selectable), |item| {
                                item.aria_active_descendant()
                            })
                            .toggle_state(Some(ix) == self.selected_index)
                            .selectable(selectable)
                            .when(selectable, |item| {
                                item.on_click({
                                    let context = self.action_context.clone();
                                    move |_, window, cx| {
                                        handler(context.as_ref(), window, cx);
                                        menu.update(cx, |menu, cx| {
                                            menu.finish_confirm(window, cx);
                                        })
                                        .ok();
                                    }
                                })
                            })
                            .child(entry_render(window, cx)),
                    )
                    .into_any_element()
            }
            ContextMenuItem::Submenu(submenu) => self
                .render_submenu_item_trigger(
                    ix,
                    submenu,
                    is_active_descendant(!submenu.disabled),
                    window,
                    cx,
                )
                .into_any_element(),
        }
    }

    fn render_submenu_item_trigger(
        &self,
        ix: usize,
        submenu: &ContextMenuSubmenu,
        is_active_descendant: bool,
        window: &mut Window,
        cx: &mut Context<Self>,
    ) -> impl IntoElement {
        let ContextMenuSubmenu {
            label,
            trigger_render,
            icon,
            icon_color,
            disabled,
            ..
        } = submenu;
        let disabled = *disabled;
        let toggle_state = Some(ix) == self.selected_index
            || matches!(
                &self.submenu_state,
                SubmenuState::Open(open_submenu) if open_submenu.item_index == ix
            );
        let submenu = match &self.submenu_state {
            SubmenuState::Open(open_submenu) if open_submenu.item_index == ix => self
                .submenu_trigger_bounds
                .borrow()
                .get(&ix)
                .copied()
                .map(|bounds| (open_submenu.entity.clone(), bounds)),
            _ => None,
        };

        div()
            .id(("context-menu-submenu-trigger", ix))
            .relative()
            .capture_any_mouse_down(cx.listener(move |this, event: &MouseDownEvent, _, _| {
                // This prevents on_hover(false) from closing the submenu during a click.
                if event.button == MouseButton::Left {
                    this.submenu_trigger_mouse_down = true;
                }
            }))
            .capture_any_mouse_up(cx.listener(move |this, event: &MouseUpEvent, _, _| {
                if event.button == MouseButton::Left {
                    this.submenu_trigger_mouse_down = false;
                }
            }))
            // Hovering opens and focuses the submenu, so the pointer usually still rests here
            // while the user types. A keypress must not count as the pointer leaving.
            .hover_listener_mode(HoverListenerMode::InputModalityIndependent)
            .on_hover(cx.listener(move |this, hovered, window, cx| {
                if disabled {
                    return;
                }
                if *hovered {
                    this.clear_selected();
                    this.suppress_focus_selection = true;
                    window.focus(&this.focus_handle.clone(), cx);
                    this.hover_target = HoverTarget::MainMenu;
                    if let Some(ContextMenuItem::Submenu(submenu)) = this.items.get(ix) {
                        if !submenu.disabled {
                            this.open_submenu(
                                ix,
                                submenu.builder.clone(),
                                SubmenuOpenTrigger::Pointer,
                                window,
                                cx,
                            );
                        }
                    }

                    cx.notify();
                } else {
                    if this.submenu_trigger_mouse_down {
                        return;
                    }

                    let is_open_for_this_item = matches!(
                        &this.submenu_state,
                        SubmenuState::Open(open_submenu) if open_submenu.item_index == ix
                    );

                    let mouse_in_submenu_zone = this
                        .padded_submenu_bounds()
                        .is_some_and(|bounds| bounds.contains(&window.mouse_position()));

                    if is_open_for_this_item
                        && this.hover_target != HoverTarget::Submenu
                        && !mouse_in_submenu_zone
                    {
                        this.close_submenu(false, cx);
                        this.clear_selected();
                        this.suppress_focus_selection = true;
                        window.focus(&this.focus_handle.clone(), cx);
                        cx.notify();
                    }
                }
            }))
            .child(
                canvas(
                    {
                        let trigger_bounds = self.submenu_trigger_bounds.clone();
                        move |bounds, _window, _cx| {
                            trigger_bounds.borrow_mut().insert(ix, bounds);
                        }
                    },
                    |_bounds, _state, _window, _cx| {},
                )
                .size_full()
                .absolute()
                .top_0()
                .left_0(),
            )
            .child(
                ListItem::new(ix)
                    .inset(true)
                    .spacing(self.spacing)
                    .disabled(disabled)
                    .aria_role(Role::MenuItem)
                    .when(is_active_descendant, |item| item.aria_active_descendant())
                    .aria_label(label.clone())
                    .toggle_state(toggle_state)
                    .on_click(cx.listener(move |this, _, window, cx| {
                        if matches!(
                            &this.submenu_state,
                            SubmenuState::Open(open_submenu) if open_submenu.item_index == ix
                        ) {
                            return;
                        }

                        if let Some(ContextMenuItem::Submenu(submenu)) = this.items.get(ix) {
                            if !submenu.disabled {
                                this.open_submenu(
                                    ix,
                                    submenu.builder.clone(),
                                    SubmenuOpenTrigger::Pointer,
                                    window,
                                    cx,
                                );
                            }
                        }
                    }))
                    .child(match trigger_render {
                        Some(trigger_render) => trigger_render(window, cx),
                        None => h_flex()
                            .w_full()
                            .gap_2()
                            .justify_between()
                            .child(
                                h_flex()
                                    .gap_1p5()
                                    .when_some(*icon, |this, icon_name| {
                                        this.child(
                                            Icon::new(icon_name).size(IconSize::Small).color(
                                                if disabled {
                                                    Color::Disabled
                                                } else {
                                                    icon_color.unwrap_or(Color::Muted)
                                                },
                                            ),
                                        )
                                    })
                                    .child(Label::new(label.clone()).color(if disabled {
                                        Color::Disabled
                                    } else {
                                        Color::Default
                                    })),
                            )
                            .child(
                                Icon::new(IconName::ChevronRight)
                                    .size(IconSize::Small)
                                    .color(if disabled {
                                        Color::Disabled
                                    } else {
                                        Color::Muted
                                    }),
                            )
                            .into_any_element(),
                    }),
            )
            .when_some(submenu, |this, (submenu, trigger_bounds)| {
                this.child(self.render_submenu_container(ix, submenu, trigger_bounds.size, cx))
            })
    }

    fn padded_submenu_bounds(&self) -> Option<Bounds<Pixels>> {
        let bounds = self.submenu_bounds.get()?;
        Some(Bounds {
            origin: Point {
                x: bounds.origin.x - px(50.0),
                y: bounds.origin.y - px(50.0),
            },
            size: Size {
                width: bounds.size.width + px(100.0),
                height: bounds.size.height + px(100.0),
            },
        })
    }

    fn render_submenu_container(
        &self,
        ix: usize,
        submenu: Entity<ContextMenu>,
        trigger_size: Size<Pixels>,
        cx: &mut Context<Self>,
    ) -> impl IntoElement {
        let bounds_cell = self.submenu_bounds.clone();
        let canvas = canvas(
            {
                move |bounds, _window, _cx| {
                    bounds_cell.set(Some(bounds));
                }
            },
            |_bounds, _state, _window, _cx| {},
        )
        .size_full()
        .absolute()
        .top_0()
        .left_0();

        // Anchored uses its own layout origin; this zero-sized child pins that
        // origin to the trigger's top-left instead of below the row's contents.
        div().absolute().top_0().left_0().w(px(0.)).h(px(0.)).child(
            deferred(
                anchored()
                    .position_mode(AnchoredPositionMode::Local)
                    .attach(
                        Bounds::new(Point::default(), trigger_size),
                        Anchor::TopRight,
                    )
                    .anchor(Anchor::TopLeft)
                    .offset(point(px(-2.), px(0.)))
                    .snap_to_window_with_margin(px(8.0))
                    .child(
                        div()
                            .id(("submenu-container", ix))
                            .on_hover(cx.listener(|this, hovered, _, _| {
                                if *hovered {
                                    this.hover_target = HoverTarget::Submenu;
                                }
                            }))
                            .occlude()
                            .child(canvas)
                            .child(submenu),
                    ),
            )
            .with_priority(self.submenu_depth + 2),
        )
    }

    fn render_menu_entry(
        &self,
        ix: usize,
        entry: &ContextMenuEntry,
        is_active_descendant: bool,
        window: &mut Window,
        cx: &mut Context<Self>,
    ) -> impl IntoElement {
        let ContextMenuEntry {
            toggle,
            label,
            handler,
            icon,
            custom_icon_path,
            custom_icon_svg,
            icon_position,
            icon_size,
            icon_color,
            action,
            disabled,
            documentation_aside,
            end_slot_icon,
            end_slot_title,
            end_slot_handler,
            show_end_slot_on_hover,
            secondary_handler: _,
        } = entry;
        let this = cx.weak_entity();
        // Report the item's keyboard shortcut to assistive technology, resolving
        // the action's binding the same way the visible accelerator (rendered
        // below) is.
        let keyboard_shortcut = action.as_ref().and_then(|action| {
            let binding = self
                .action_context
                .as_ref()
                .map(|focus| KeyBinding::for_action_in(&**action, focus, cx))
                .unwrap_or_else(|| KeyBinding::for_action(&**action, cx));
            binding.keyboard_shortcut_text(window, cx)
        });

        let handler = handler.clone();
        let menu = cx.entity().downgrade();

        let icon_color = if *disabled {
            Color::Muted
        } else if toggle.is_some() {
            icon_color.unwrap_or(Color::Accent)
        } else {
            icon_color.unwrap_or(Color::Default)
        };

        let label_color = if *disabled {
            Color::Disabled
        } else {
            Color::Default
        };

        let label_element = if let Some(custom_path) = custom_icon_path {
            h_flex()
                .gap_1p5()
                .when(
                    *icon_position == IconPosition::Start && toggle.is_none(),
                    |flex| {
                        flex.child(
                            Icon::from_path(custom_path.clone())
                                .size(*icon_size)
                                .color(icon_color),
                        )
                    },
                )
                .child(Label::new(label.clone()).color(label_color).truncate())
                .when(*icon_position == IconPosition::End, |flex| {
                    flex.child(
                        Icon::from_path(custom_path.clone())
                            .size(*icon_size)
                            .color(icon_color),
                    )
                })
                .into_any_element()
        } else if let Some(custom_icon_svg) = custom_icon_svg {
            h_flex()
                .gap_1p5()
                .when(
                    *icon_position == IconPosition::Start && toggle.is_none(),
                    |flex| {
                        flex.child(
                            Icon::from_external_svg(custom_icon_svg.clone())
                                .size(*icon_size)
                                .color(icon_color),
                        )
                    },
                )
                .child(Label::new(label.clone()).color(label_color).truncate())
                .when(*icon_position == IconPosition::End, |flex| {
                    flex.child(
                        Icon::from_external_svg(custom_icon_svg.clone())
                            .size(*icon_size)
                            .color(icon_color),
                    )
                })
                .into_any_element()
        } else if let Some(icon_name) = icon {
            h_flex()
                .gap_1p5()
                .when(
                    *icon_position == IconPosition::Start && toggle.is_none(),
                    |flex| flex.child(Icon::new(*icon_name).size(*icon_size).color(icon_color)),
                )
                .child(Label::new(label.clone()).color(label_color).truncate())
                .when(*icon_position == IconPosition::End, |flex| {
                    flex.child(Icon::new(*icon_name).size(*icon_size).color(icon_color))
                })
                .into_any_element()
        } else {
            Label::new(label.clone())
                .color(label_color)
                .truncate()
                .into_any_element()
        };

        let aside_trigger_bounds = self.aside_trigger_bounds.clone();

        div()
            .id(("context-menu-child", ix))
            .when_some(documentation_aside.clone(), |this, documentation_aside| {
                this.occlude()
                    .on_hover(cx.listener(move |menu, hovered, _, cx| {
                        if *hovered {
                            menu.documentation_aside = Some((ix, documentation_aside.clone()));
                        } else if matches!(menu.documentation_aside, Some((id, _)) if id == ix) {
                            menu.documentation_aside = None;
                        }
                        cx.notify();
                    }))
            })
            .when(documentation_aside.is_some(), |this| {
                this.child(
                    canvas(
                        {
                            let aside_trigger_bounds = aside_trigger_bounds.clone();
                            move |bounds, _window, _cx| {
                                aside_trigger_bounds.borrow_mut().insert(ix, bounds);
                            }
                        },
                        |_bounds, _state, _window, _cx| {},
                    )
                    .size_full()
                    .absolute()
                    .top_0()
                    .left_0(),
                )
            })
            .child(
                ListItem::new(ix)
                    .group_name("label_container")
                    .inset(true)
                    .spacing(self.spacing)
                    .disabled(*disabled)
                    .aria_role(if toggle.is_some() {
                        Role::MenuItemCheckBox
                    } else {
                        Role::MenuItem
                    })
                    .when_some(*toggle, |item, (_, checked)| item.aria_checked(checked))
                    .when(is_active_descendant, |item| item.aria_active_descendant())
                    .aria_label(label.clone())
                    .when_some(keyboard_shortcut, |item, keyboard_shortcut| {
                        item.aria_keyshortcuts(keyboard_shortcut)
                    })
                    .toggle_state(Some(ix) == self.selected_index)
                    .when(self.main_menu.is_none() && !*disabled, |item| {
                        item.on_hover(cx.listener(move |this, hovered, window, cx| {
                            if *hovered {
                                this.clear_selected();
                                this.suppress_focus_selection = true;
                                window.focus(&this.focus_handle.clone(), cx);

                                if let SubmenuState::Open(open_submenu) = &this.submenu_state {
                                    if open_submenu.item_index != ix {
                                        this.close_submenu(false, cx);
                                        cx.notify();
                                    }
                                }
                            }
                        }))
                    })
                    .when(self.main_menu.is_some(), |item| {
                        item.on_click(cx.listener(move |this, _, window, cx| {
                            if matches!(
                                &this.submenu_state,
                                SubmenuState::Open(open_submenu) if open_submenu.item_index == ix
                            ) {
                                return;
                            }

                            if let Some(ContextMenuItem::Submenu(submenu)) = this.items.get(ix) {
                                this.open_submenu(
                                    ix,
                                    submenu.builder.clone(),
                                    SubmenuOpenTrigger::Pointer,
                                    window,
                                    cx,
                                );
                            }
                        }))
                        .on_hover(cx.listener(
                            move |this, hovered, window, cx| {
                                if *hovered {
                                    this.clear_selected();
                                    cx.notify();
                                }

                                if let Some(parent) = &this.main_menu {
                                    let mouse_pos = window.mouse_position();
                                    let parent_clone = parent.clone();

                                    if *hovered {
                                        parent.update(cx, |parent, _| {
                                            parent.clear_selected();
                                            parent.hover_target = HoverTarget::Submenu;
                                        });
                                    } else {
                                        parent_clone.update(cx, |parent, cx| {
                                            if matches!(
                                                &parent.submenu_state,
                                                SubmenuState::Open(_)
                                            ) {
                                                if !parent.padded_submenu_bounds().is_some_and(
                                                    |bounds| bounds.contains(&mouse_pos),
                                                ) {
                                                    parent.close_submenu(true, cx);
                                                }
                                            }
                                        });
                                    }
                                }
                            },
                        ))
                    })
                    .when_some(*toggle, |list_item, (position, toggled)| {
                        let contents = div()
                            .flex_none()
                            .child(
                                Icon::new(icon.unwrap_or(IconName::Check))
                                    .color(icon_color)
                                    .size(*icon_size),
                            )
                            .when(!toggled, |contents| contents.invisible());

                        match position {
                            IconPosition::Start => list_item.start_slot(contents),
                            IconPosition::End => list_item.end_slot(contents),
                        }
                    })
                    .child(
                        h_flex()
                            .w_full()
                            .justify_between()
                            .child(label_element)
                            .debug_selector(|| format!("MENU_ITEM-{}", label))
                            .children(action.as_ref().map(|action| {
                                let binding = self
                                    .action_context
                                    .as_ref()
                                    .map(|focus| KeyBinding::for_action_in(&**action, focus, cx))
                                    .unwrap_or_else(|| KeyBinding::for_action(&**action, cx));

                                div()
                                    .ml_4()
                                    .child(binding.disabled(*disabled))
                                    .when(*disabled && documentation_aside.is_some(), |parent| {
                                        parent.invisible()
                                    })
                            }))
                            .when(*disabled && documentation_aside.is_some(), |parent| {
                                parent.child(
                                    Icon::new(IconName::Info)
                                        .size(IconSize::XSmall)
                                        .color(Color::Muted),
                                )
                            }),
                    )
                    .when_some(
                        end_slot_icon
                            .as_ref()
                            .zip(self.end_slot_action.as_ref())
                            .zip(end_slot_title.as_ref())
                            .zip(end_slot_handler.as_ref()),
                        |el, (((icon, action), title), handler)| {
                            el.end_slot({
                                let icon_button = IconButton::new("end-slot-icon", *icon)
                                    .shape(IconButtonShape::Square)
                                    .style(ButtonStyle::Subtle)
                                    .tooltip({
                                        let action_context = self.action_context.clone();
                                        let title = title.clone();
                                        let action = action.boxed_clone();
                                        move |_window, cx| {
                                            action_context
                                                .as_ref()
                                                .map(|focus| {
                                                    Tooltip::for_action_in(
                                                        title.clone(),
                                                        &*action,
                                                        focus,
                                                        cx,
                                                    )
                                                })
                                                .unwrap_or_else(|| {
                                                    Tooltip::for_action(title.clone(), &*action, cx)
                                                })
                                        }
                                    })
                                    .on_click({
                                        let handler = handler.clone();
                                        move |_, window, cx| {
                                            handler(None, window, cx);
                                            this.update(cx, |this, cx| {
                                                this.rebuild(window, cx);
                                                cx.notify();
                                            })
                                            .ok();
                                        }
                                    });

                                if *show_end_slot_on_hover {
                                    div()
                                        .visible_on_hover("label_container")
                                        .child(icon_button)
                                        .into_any_element()
                                } else {
                                    icon_button.into_any_element()
                                }
                            })
                        },
                    )
                    .on_click({
                        let context = self.action_context.clone();
                        move |_, window, cx| {
                            handler(context.as_ref(), window, cx);
                            menu.update(cx, |menu, cx| {
                                menu.finish_confirm(window, cx);
                            })
                            .ok();
                        }
                    }),
            )
            .into_any_element()
    }

    #[inline(never)]
    fn new_inner(window: &mut Window, cx: &mut Context<Self>) -> Self {
        let focus_handle = cx.retained_focus_handle();
        let _on_blur_subscription = cx.on_blur(
            &focus_handle,
            window,
            |context_menu: &mut ContextMenu, window, cx| {
                if let Some(ignore_until) = context_menu.ignore_blur_until {
                    if Instant::now() < ignore_until {
                        return;
                    } else {
                        context_menu.ignore_blur_until = None;
                    }
                }

                if context_menu.main_menu.is_none() {
                    if let SubmenuState::Open(open_submenu) = &context_menu.submenu_state {
                        let submenu_focus = open_submenu.entity.read(cx).focus_handle.clone();
                        if submenu_focus.contains_focused(window, cx) {
                            return;
                        }
                    }
                }

                context_menu.cancel(&menu::Cancel, window, cx)
            },
        );
        window.refresh();

        if window.is_a11y_enabled() {
            // When the menu first receives focus (i.e. when it opens), move the
            // selection onto a menu item so assistive technology announces a real
            // item rather than the bare menu container. Per the ARIA menu button
            // pattern, opening a menu places focus on a menu item; for select-style
            // menus we prefer the currently-checked item. We only do this when
            // nothing is selected yet so we don't override an existing selection.
            cx.on_focus_in(&focus_handle, window, |context_menu, window, cx| {
                if context_menu.selected_index.is_none() && !context_menu.suppress_focus_selection {
                    context_menu.select_toggled_or_first(window, cx);
                }
                context_menu.suppress_focus_selection = false;
            })
            .detach();
        }

        Self {
            builder: None,
            items: Vec::new(),
            focus_handle,
            action_context: None,
            selected_index: None,
            delayed: false,
            clicked: false,
            end_slot_action: None,
            key_context: SharedString::from("menu"),
            _on_blur_subscription: Some(_on_blur_subscription),
            keep_open_on_confirm: false,
            rebuild_parent_on_confirm: false,
            fixed_width: None,
            spacing: ListItemSpacing::default(),
            main_menu: None,
            main_menu_observed_bounds: Rc::new(Cell::new(None)),
            documentation_aside: None,
            aside_trigger_bounds: Rc::new(RefCell::new(HashMap::default())),
            submenu_state: SubmenuState::Closed,
            hover_target: HoverTarget::MainMenu,
            submenu_trigger_bounds: Rc::new(RefCell::new(HashMap::default())),
            submenu_bounds: Rc::new(Cell::new(None)),
            submenu_depth: 0,
            submenu_trigger_mouse_down: false,
            content_focus_handle: None,
            ignore_blur_until: None,
            suppress_focus_selection: !window.is_a11y_enabled(),
        }
    }
}

impl ContextMenuItem {
    fn is_selectable(&self) -> bool {
        match self {
            ContextMenuItem::Header(_)
            | ContextMenuItem::HeaderWithLink(_, _, _)
            | ContextMenuItem::Separator
            | ContextMenuItem::Label { .. }
            | ContextMenuItem::EmbeddedView(_) => false,
            ContextMenuItem::Entry(ContextMenuEntry { disabled, .. }) => !disabled,
            ContextMenuItem::CustomEntry { selectable, .. } => *selectable,
            ContextMenuItem::Submenu(submenu) => !submenu.disabled,
        }
    }
}

impl Render for ContextMenu {
    fn render(&mut self, window: &mut Window, cx: &mut Context<Self>) -> impl IntoElement {
        let theme_settings = theme::theme_settings(cx);
        let ui_font_size = theme_settings.ui_font_size(cx);
        let ui_font_family = theme_settings.ui_font(cx).family.clone();
        // Menus can be deferred from inside elements that override the text
        // style (e.g. the editor with a custom `buffer_line_height`), so always
        // apply the default line height to render the same everywhere.
        let line_height = relative(BufferLineHeight::Comfortable.value());
        let window_size = window.viewport_size();
        let rem_size = window.rem_size();
        let is_wide_window = window_size.width / rem_size > rems_from_px(800_f32).0;

        let focus_submenu = match &self.submenu_state {
            SubmenuState::Open(open_submenu)
                if self
                    .submenu_trigger_bounds
                    .borrow()
                    .contains_key(&open_submenu.item_index) =>
            {
                let submenu = open_submenu.entity.read(cx);
                Some((submenu.focus_handle.clone(), submenu.submenu_focus_target()))
            }
            _ => None,
        };

        let aside = self.documentation_aside.clone();
        let render_aside = |aside: DocumentationAside, cx: &mut Context<Self>| {
            WithRemSize::new(ui_font_size)
                .occlude()
                .font_family(ui_font_family.clone())
                .line_height(line_height)
                .elevation_2(cx)
                .w_full()
                .p_2()
                .overflow_hidden()
                .when(is_wide_window, |this| this.max_w_96())
                .when(!is_wide_window, |this| this.max_w_48())
                .child((aside.render)(cx))
        };

        let render_menu = |cx: &mut Context<Self>, window: &mut Window| {
            let bounds_cell = self.main_menu_observed_bounds.clone();
            let menu_bounds_measure = canvas(
                {
                    move |bounds, _window, _cx| {
                        bounds_cell.set(Some(bounds));
                    }
                },
                |_bounds, _state, _window, _cx| {},
            )
            .size_full()
            .absolute()
            .top_0()
            .left_0();

            WithRemSize::new(ui_font_size)
                .occlude()
                .font_family(ui_font_family.clone())
                .line_height(line_height)
                .elevation_2(cx)
                .flex()
                .flex_row()
                .flex_shrink_0()
                .child(
                    v_flex()
                        .id("context-menu")
                        .role(Role::Menu)
                        .max_h(vh(0.75, window))
                        .flex_shrink_0()
                        .child(menu_bounds_measure)
                        .when_some(self.fixed_width, |this, width| {
                            this.w(width).overflow_x_hidden()
                        })
                        .when(self.fixed_width.is_none(), |this| {
                            this.min_w(CONTEXT_MENU_MIN_WIDTH).flex_1()
                        })
                        .overflow_y_scroll()
                        .track_focus(&self.focus_handle(cx))
                        .key_context(self.key_context.as_ref())
                        .on_action(cx.listener(ContextMenu::select_first))
                        .on_action(cx.listener(ContextMenu::handle_select_last))
                        .on_action(cx.listener(ContextMenu::select_next))
                        .on_action(cx.listener(ContextMenu::select_previous))
                        .on_action(cx.listener(ContextMenu::select_submenu_child))
                        .on_action(cx.listener(ContextMenu::select_submenu_parent))
                        .on_action(cx.listener(ContextMenu::confirm))
                        .on_action(cx.listener(ContextMenu::secondary_confirm))
                        .on_action(cx.listener(ContextMenu::cancel))
                        .on_hover(cx.listener(|this, hovered: &bool, _, cx| {
                            if *hovered {
                                this.hover_target = HoverTarget::MainMenu;
                                if let Some(parent) = &this.main_menu {
                                    parent.update(cx, |parent, _| {
                                        parent.hover_target = HoverTarget::Submenu;
                                    });
                                }
                            }
                        }))
                        .on_mouse_down_out(cx.listener(
                            |this, event: &MouseDownEvent, window, cx| {
                                if matches!(&this.submenu_state, SubmenuState::Open(_)) {
                                    if let Some(padded_bounds) = this.padded_submenu_bounds() {
                                        if padded_bounds.contains(&event.position) {
                                            return;
                                        }
                                    }
                                }

                                if let Some(parent) = &this.main_menu {
                                    let parent = parent.read(cx);
                                    let overridden_by_parent_trigger = match &parent.submenu_state {
                                        SubmenuState::Open(open_submenu) => parent
                                            .submenu_trigger_bounds
                                            .borrow()
                                            .get(&open_submenu.item_index)
                                            .is_some_and(|bounds| bounds.contains(&event.position)),
                                        SubmenuState::Closed => false,
                                    };
                                    if overridden_by_parent_trigger {
                                        return;
                                    }
                                }

                                this.cancel(&menu::Cancel, window, cx)
                            },
                        ))
                        .when_some(self.end_slot_action.as_ref(), |el, action| {
                            el.on_boxed_action(&**action, cx.listener(ContextMenu::end_slot))
                        })
                        .when(!self.delayed, |mut el| {
                            for item in self.items.iter() {
                                if let ContextMenuItem::Entry(ContextMenuEntry {
                                    action: Some(action),
                                    disabled: false,
                                    ..
                                }) = item
                                {
                                    el = el.on_boxed_action(
                                        &**action,
                                        cx.listener(ContextMenu::on_action_dispatch),
                                    );
                                }
                            }
                            el
                        })
                        .map(|this| {
                            let only_embedded_views = !self.items.is_empty()
                                && self
                                    .items
                                    .iter()
                                    .all(|item| matches!(item, ContextMenuItem::EmbeddedView(_)));
                            let items = self
                                .items
                                .iter()
                                .enumerate()
                                .map(|(ix, item)| self.render_menu_item(ix, item, window, cx));
                            if only_embedded_views {
                                this.children(items)
                            } else {
                                this.child(List::new().children(items))
                            }
                        }),
                )
        };

        // Clicking content that can't take focus leaves focus on the submenu itself.
        if let Some((submenu_focus_handle, focus_target)) = focus_submenu.as_ref()
            && (!submenu_focus_handle.contains_focused(window, cx)
                || submenu_focus_handle.is_focused(window))
        {
            window.focus(focus_target, cx);
        }

        if is_wide_window {
            let menu_bounds = self.main_menu_observed_bounds.get();
            let trigger_bounds = self
                .documentation_aside
                .as_ref()
                .and_then(|(ix, _)| self.aside_trigger_bounds.borrow().get(ix).copied());

            let trigger_position = match (menu_bounds, trigger_bounds) {
                (Some(menu_bounds), Some(trigger_bounds)) => {
                    let relative_top = trigger_bounds.origin.y - menu_bounds.origin.y;
                    let height = trigger_bounds.size.height;
                    Some((relative_top, height))
                }
                _ => None,
            };

            div()
                .relative()
                .child(render_menu(cx, window))
                // Only render the aside once we have trigger bounds to avoid flicker.
                .when_some(trigger_position, |this, (top, height)| {
                    this.children(aside.map(|(_, aside)| {
                        h_flex()
                            .absolute()
                            .when(aside.side == DocumentationSide::Left, |el| {
                                el.right_full().mr_1()
                            })
                            .when(aside.side == DocumentationSide::Right, |el| {
                                el.left_full().ml_1()
                            })
                            .top(top)
                            .h(height)
                            .child(render_aside(aside, cx))
                    }))
                })
        } else {
            v_flex()
                .w_full()
                .relative()
                .gap_1()
                .justify_end()
                .children(aside.map(|(_, aside)| render_aside(aside, cx)))
                .child(render_menu(cx, window))
        }
    }
}

#[cfg(test)]
mod tests {
    use gpui::{Modifiers, TestAppContext, VisualTestContext, size};

    use super::*;

    struct SubmenuTestView {
        menu: Entity<ContextMenu>,
        left: Pixels,
    }

    impl Render for SubmenuTestView {
        fn render(&mut self, _: &mut Window, _: &mut Context<Self>) -> impl IntoElement {
            div().size_full().child(
                div()
                    .absolute()
                    .left(self.left)
                    .top(px(40.))
                    .child(self.menu.clone()),
            )
        }
    }

    fn submenu_test_window(
        cx: &mut TestAppContext,
        build: impl FnOnce(&mut Window, &mut App) -> Entity<ContextMenu>,
    ) -> (Entity<ContextMenu>, VisualTestContext) {
        cx.update(|cx| {
            let settings_store = settings::SettingsStore::test(cx);
            cx.set_global(settings_store);
            theme_settings::init(theme::LoadThemes::JustBase, cx);
        });
        let window = cx.open_window(size(px(700.), px(400.)), |window, cx| SubmenuTestView {
            menu: build(window, cx),
            left: px(40.),
        });
        let menu = window
            .update(cx, |view, _, _| view.menu.clone())
            .expect("menu");
        let mut visual = VisualTestContext::from_window(window.into(), cx);
        visual.update(|window, cx| window.draw(cx).clear(cx));
        (menu, visual)
    }

    fn open_selected_submenu(
        menu: &Entity<ContextMenu>,
        cx: &mut VisualTestContext,
    ) -> Entity<ContextMenu> {
        menu.update_in(cx, |menu, window, cx| {
            menu.select_submenu_child(&SelectChild, window, cx);
        });
        cx.update(|window, cx| window.draw(cx).clear(cx));
        menu.read_with(cx, |menu, _| match &menu.submenu_state {
            SubmenuState::Open(open) => open.entity.clone(),
            SubmenuState::Closed => panic!("submenu should be open"),
        })
    }

    #[gpui::test]
    fn custom_submenu_trigger_keeps_menu_interactions(cx: &mut TestAppContext) {
        let (menu, mut visual) = submenu_test_window(cx, |window, cx| {
            ContextMenu::build(window, cx, |menu, _, _| {
                menu.item(
                    ContextMenuSubmenu::new("Disabled submenu", |_, _, _| {
                        panic!("disabled submenu must not open")
                    })
                    .disabled(true)
                    .custom_trigger(|_, _| {
                        div()
                            .debug_selector(|| "disabled-trigger".into())
                            .child(Label::new("Unavailable").color(Color::Disabled))
                            .into_any_element()
                    }),
                )
                .item(
                    ContextMenuSubmenu::new("Group by", |menu, _, _| {
                        menu.entry("Project", None, |_, _| {})
                    })
                    .custom_trigger(|_, _| {
                        h_flex()
                            .debug_selector(|| "custom-trigger".into())
                            .w_full()
                            .justify_between()
                            .child(Label::new("Group by"))
                            .child(Label::new("Project").color(Color::Muted))
                            .into_any_element()
                    }),
                )
            })
        });
        let disabled_bounds = visual
            .debug_bounds("disabled-trigger")
            .expect("disabled custom content");
        visual.simulate_mouse_move(disabled_bounds.center(), None, Modifiers::default());
        visual.simulate_click(disabled_bounds.center(), Modifiers::default());
        menu.read_with(&visual, |menu, _| {
            assert!(matches!(menu.submenu_state, SubmenuState::Closed));
        });

        menu.update_in(&mut visual, |menu, window, cx| {
            window.focus(&menu.focus_handle, cx);
            menu.select_first(&SelectFirst, window, cx);
            assert_eq!(menu.selected_index(), Some(1));
        });
        let submenu = open_selected_submenu(&menu, &mut visual);
        visual.update(|window, cx| assert!(submenu.focus_handle(cx).is_focused(window)));
        visual.dispatch_action(SelectParent);
        visual.run_until_parked();
        menu.read_with(&visual, |menu, _| {
            assert!(matches!(menu.submenu_state, SubmenuState::Closed));
            assert_eq!(menu.selected_index(), Some(1));
        });
        visual.update(|window, cx| {
            assert!(menu.focus_handle(cx).is_focused(window));
            window.draw(cx).clear(cx);
        });

        let bounds = visual
            .debug_bounds("custom-trigger")
            .expect("custom content");
        visual.simulate_click(bounds.center(), Modifiers::default());
        menu.read_with(&visual, |menu, _| {
            assert!(matches!(menu.submenu_state, SubmenuState::Open(_)));
        });
        visual.dispatch_action(SelectParent);
        visual.run_until_parked();
        visual.simulate_mouse_move(disabled_bounds.center(), None, Modifiers::default());
        visual.simulate_mouse_move(bounds.center(), None, Modifiers::default());
        visual.run_until_parked();
        let submenu = menu.read_with(&visual, |menu, _| match &menu.submenu_state {
            SubmenuState::Open(open) => open.entity.clone(),
            SubmenuState::Closed => panic!("hover should open the submenu"),
        });

        let dismissals = Rc::new(Cell::new(0));
        let _subscription = visual.update(|_, cx| {
            let dismissals = dismissals.clone();
            cx.subscribe(&menu, move |_, _: &DismissEvent, _| {
                dismissals.set(dismissals.get() + 1);
            })
        });
        submenu.update_in(&mut visual, |submenu, window, cx| {
            submenu.select_first(&SelectFirst, window, cx);
        });
        visual.dispatch_action(menu::Confirm);
        visual.run_until_parked();
        assert_eq!(dismissals.get(), 1);
    }

    #[gpui::test]
    fn persistent_submenu_refreshes_for_mouse_and_keyboard(cx: &mut TestAppContext) {
        let changes = Rc::new(Cell::new(0));
        let builds = Rc::new(Cell::new(0));
        let (menu, mut visual) = submenu_test_window(cx, |window, cx| {
            ContextMenu::build(window, cx, {
                let changes = changes.clone();
                let builds = builds.clone();
                move |menu, _, _| {
                    menu.submenu("Filters", move |menu, _, _| {
                        builds.set(builds.get() + 1);
                        let count = changes.get();
                        menu.keep_open_on_confirm(true)
                            .header(format!("Changes: {count}"))
                            .item(
                                ContextMenuEntry::new("Toggle")
                                    .toggleable(IconPosition::End, count % 2 != 0)
                                    .handler({
                                        let changes = changes.clone();
                                        move |_, _| changes.set(changes.get() + 1)
                                    }),
                            )
                            .custom_entry(
                                |_, _| {
                                    div()
                                        .debug_selector(|| "custom-toggle".into())
                                        .child("Custom")
                                        .into_any_element()
                                },
                                {
                                    let changes = changes.clone();
                                    move |_, _| changes.set(changes.get() + 1)
                                },
                            )
                    })
                }
            })
        });
        let dismissals = Rc::new(Cell::new(0));
        let _subscription = visual.update(|_, cx| {
            let dismissals = dismissals.clone();
            cx.subscribe(&menu, move |_, _: &DismissEvent, _| {
                dismissals.set(dismissals.get() + 1);
            })
        });
        menu.update_in(&mut visual, |menu, window, cx| {
            menu.select_first(&SelectFirst, window, cx)
        });
        let submenu = open_selected_submenu(&menu, &mut visual);
        let focus = visual.update(|_, cx| submenu.focus_handle(cx));

        for count in 1..=4 {
            match count {
                1 | 2 => {
                    let selector = if count == 1 {
                        "MENU_ITEM-Toggle"
                    } else {
                        "custom-toggle"
                    };
                    let bounds = visual.debug_bounds(selector).expect("entry bounds");
                    visual.simulate_click(bounds.center(), Modifiers::default());
                }
                _ => {
                    submenu.update_in(&mut visual, |menu, window, cx| {
                        menu.select_first(&SelectFirst, window, cx);
                    });
                    if count == 3 {
                        visual.dispatch_action(menu::Confirm);
                    } else {
                        visual.dispatch_action(menu::SecondaryConfirm);
                    }
                }
            }
            visual.run_until_parked();
            visual.update(|window, cx| {
                window.draw(cx).clear(cx);
                assert!(focus.is_focused(window));
            });
            assert_eq!(changes.get(), count);
            assert_eq!(
                builds.get(),
                count + 1,
                "rebuild once per confirmation, not per frame"
            );
            submenu.read_with(&visual, |submenu, _| {
                assert!(matches!(submenu.items.first(), Some(ContextMenuItem::Header(label)) if label.as_ref() == format!("Changes: {count}")));
                assert!(matches!(submenu.items.get(1), Some(ContextMenuItem::Entry(entry)) if entry.toggle == Some((IconPosition::End, count % 2 != 0))));
                assert!(!submenu.clicked);
            });
            menu.read_with(&visual, |menu, _| {
                assert!(matches!(&menu.submenu_state, SubmenuState::Open(open) if open.entity == submenu));
            });
            assert_eq!(dismissals.get(), 0);
        }

        visual.dispatch_action(menu::Cancel);
        visual.run_until_parked();
        assert_eq!(
            dismissals.get(),
            0,
            "Escape after a keep-open click must not dismiss the parent"
        );
        menu.read_with(&visual, |menu, _| {
            assert!(matches!(menu.submenu_state, SubmenuState::Closed))
        });
        visual.update(|window, cx| assert!(menu.focus_handle(cx).is_focused(window)));
    }

    #[gpui::test]
    fn persistent_submenu_removal_repairs_selection_and_returns_focus(cx: &mut TestAppContext) {
        let remaining = Rc::new(Cell::new(2));
        let (menu, mut visual) = submenu_test_window(cx, |window, cx| {
            ContextMenu::build(window, cx, {
                let remaining = remaining.clone();
                move |menu, _, _| {
                    menu.submenu("Filters", move |menu, _, _| {
                        let mut menu = menu.keep_open_on_confirm(true).header("Available filters");
                        for index in 0..remaining.get() {
                            let remaining = remaining.clone();
                            menu = menu.entry(format!("Filter {index}"), None, move |_, _| {
                                remaining.set(remaining.get() - 1);
                            });
                        }
                        menu.item(ContextMenuEntry::new("Unavailable").disabled(true))
                    })
                }
            })
        });
        menu.update_in(&mut visual, |menu, window, cx| {
            menu.select_first(&SelectFirst, window, cx)
        });
        let submenu = open_selected_submenu(&menu, &mut visual);
        submenu.update_in(&mut visual, |submenu, window, cx| {
            submenu.select_last(window, cx);
            submenu.confirm(&menu::Confirm, window, cx);
            assert_eq!(submenu.selected_index(), Some(1));
        });
        visual.run_until_parked();
        submenu.update_in(&mut visual, |submenu, window, cx| {
            submenu.confirm(&menu::Confirm, window, cx);
        });
        visual.run_until_parked();
        menu.read_with(&visual, |menu, _| {
            assert!(matches!(menu.submenu_state, SubmenuState::Closed));
            assert_eq!(menu.selected_index(), Some(0));
        });
        visual.update(|window, cx| assert!(menu.focus_handle(cx).is_focused(window)));
        assert_eq!(remaining.get(), 0);
    }

    #[gpui::test]
    fn persistent_submenu_can_refresh_and_disable_its_parent_trigger(cx: &mut TestAppContext) {
        let remaining = Rc::new(Cell::new(2));
        let (menu, mut visual) = submenu_test_window(cx, |window, cx| {
            ContextMenu::build_persistent(window, cx, {
                let remaining = remaining.clone();
                move |menu, _, _| {
                    let count = remaining.get();
                    menu.entry("Before", None, |_, _| {})
                        .when(count < 2, |menu| menu.header("Updated"))
                        .when(count == 0, |menu| menu.header("No filters"))
                        .item(
                            ContextMenuSubmenu::new(format!("Filters ({count})"), {
                                let remaining = remaining.clone();
                                move |menu, _, _| {
                                    let mut menu = menu
                                        .keep_open_on_confirm(true)
                                        .rebuild_parent_on_confirm(true);
                                    for index in 0..count {
                                        let remaining = remaining.clone();
                                        menu = menu.entry(
                                            format!("Filter {index}"),
                                            None,
                                            move |_, _| {
                                                remaining.set(remaining.get() - 1);
                                            },
                                        );
                                    }
                                    menu
                                }
                            })
                            .id("filters")
                            .disabled(count == 0)
                            .custom_trigger(move |_, _| {
                                div()
                                    .debug_selector(move || {
                                        match count {
                                            0 => "no-filters",
                                            1 => "one-filter",
                                            _ => "two-filters",
                                        }
                                        .into()
                                    })
                                    .child(Label::new(format!("{count} filters")).color(
                                        if count == 0 {
                                            Color::Disabled
                                        } else {
                                            Color::Default
                                        },
                                    ))
                                    .into_any_element()
                            }),
                        )
                        .entry("After", None, |_, _| {})
                }
            })
        });
        assert!(visual.debug_bounds("two-filters").is_some());
        let dismissals = Rc::new(Cell::new(0));
        let _subscription = visual.update(|_, cx| {
            let dismissals = dismissals.clone();
            cx.subscribe(&menu, move |_, _: &DismissEvent, _| {
                dismissals.set(dismissals.get() + 1)
            })
        });
        menu.update_in(&mut visual, |menu, window, cx| {
            menu.select_first(&SelectFirst, window, cx);
            menu.select_next(&SelectNext, window, cx);
        });
        let submenu = open_selected_submenu(&menu, &mut visual);
        let focus = visual.update(|_, cx| submenu.focus_handle(cx));
        let bounds = visual
            .debug_bounds("MENU_ITEM-Filter 0")
            .expect("filter bounds");
        visual.simulate_click(bounds.center(), Modifiers::default());
        visual.run_until_parked();
        visual.update(|window, cx| window.draw(cx).clear(cx));
        assert!(visual.debug_bounds("one-filter").is_some());
        assert!(visual.debug_bounds("two-filters").is_none());
        menu.read_with(&visual, |menu, _| {
            assert!(matches!(&menu.submenu_state, SubmenuState::Open(open) if open.item_index == 2 && open.entity == submenu));
            assert!(matches!(menu.items.get(2), Some(ContextMenuItem::Submenu(trigger)) if trigger.label.as_ref() == "Filters (1)"));
        });
        submenu.read_with(&visual, |submenu, _| assert_eq!(submenu.items.len(), 1));
        visual.update(|window, _| assert!(focus.is_focused(window)));

        submenu.update_in(&mut visual, |submenu, window, cx| {
            submenu.select_first(&SelectFirst, window, cx)
        });
        visual.dispatch_action(menu::Confirm);
        visual.run_until_parked();
        menu.read_with(&visual, |menu, _| {
            assert!(matches!(menu.submenu_state, SubmenuState::Closed));
            assert!(matches!(menu.items.get(3), Some(ContextMenuItem::Submenu(trigger)) if trigger.disabled && trigger.label.as_ref() == "Filters (0)"));
            assert_eq!(menu.selected_index(), Some(4), "skip disabled triggers and headers");
        });
        visual.update(|window, cx| assert!(menu.focus_handle(cx).is_focused(window)));
        assert_eq!(dismissals.get(), 0);
        visual.update(|window, cx| window.draw(cx).clear(cx));
        assert!(visual.debug_bounds("no-filters").is_some());
        assert!(visual.debug_bounds("one-filter").is_none());
        let trigger_bounds = menu.read_with(&visual, |menu, _| {
            menu.submenu_trigger_bounds
                .borrow()
                .get(&3)
                .copied()
                .expect("disabled trigger bounds")
        });
        visual.simulate_mouse_move(trigger_bounds.center(), None, Modifiers::default());
        visual.simulate_click(trigger_bounds.center(), Modifiers::default());
        menu.read_with(&visual, |menu, _| {
            assert!(matches!(menu.submenu_state, SubmenuState::Closed));
            assert_eq!(menu.selected_index(), Some(4));
        });
        assert_eq!(dismissals.get(), 0);
    }

    #[gpui::test]
    fn nested_submenu_refresh_preserves_ancestors_and_focus(cx: &mut TestAppContext) {
        let count = Rc::new(Cell::new(0));
        let (menu, mut visual) = submenu_test_window(cx, |window, cx| {
            ContextMenu::build(window, cx, {
                let count = count.clone();
                move |menu, _, _| {
                    menu.submenu("Options", move |menu, _, _| {
                        menu.item(
                            ContextMenuSubmenu::new(format!("Filters ({})", count.get()), {
                                let count = count.clone();
                                move |menu, _, _| {
                                    menu.keep_open_on_confirm(true)
                                        .rebuild_parent_on_confirm(true)
                                        .entry(format!("Count: {}", count.get()), None, {
                                            let count = count.clone();
                                            move |_, _| count.set(count.get() + 1)
                                        })
                                }
                            })
                            .id("filters"),
                        )
                    })
                }
            })
        });
        let dismissals = Rc::new(Cell::new(0));
        let _subscription = visual.update(|_, cx| {
            let dismissals = dismissals.clone();
            cx.subscribe(&menu, move |_, _: &DismissEvent, _| {
                dismissals.set(dismissals.get() + 1)
            })
        });
        menu.update_in(&mut visual, |menu, window, cx| {
            menu.select_first(&SelectFirst, window, cx)
        });
        let parent = open_selected_submenu(&menu, &mut visual);
        let submenu = open_selected_submenu(&parent, &mut visual);
        visual.dispatch_action(menu::Confirm);
        visual.run_until_parked();
        visual.update(|window, cx| {
            window.draw(cx).clear(cx);
            assert!(submenu.focus_handle(cx).is_focused(window));
        });
        menu.read_with(&visual, |menu, _| {
            assert!(
                matches!(&menu.submenu_state, SubmenuState::Open(open) if open.entity == parent)
            );
        });
        parent.read_with(&visual, |parent, _| {
            assert!(matches!(&parent.submenu_state, SubmenuState::Open(open) if open.entity == submenu));
            assert!(matches!(parent.items.first(), Some(ContextMenuItem::Submenu(trigger)) if trigger.label.as_ref() == "Filters (1)"));
        });
        visual.dispatch_action(SelectParent);
        visual.run_until_parked();
        visual.update(|window, cx| assert!(parent.focus_handle(cx).is_focused(window)));
        assert_eq!(dismissals.get(), 0);
    }

    #[gpui::test]
    fn ordinary_submenu_confirmation_still_dismisses_parent(cx: &mut TestAppContext) {
        let (menu, mut visual) = submenu_test_window(cx, |window, cx| {
            ContextMenu::build_persistent(window, cx, |menu, _, _| {
                menu.submenu("Commands", |menu, _, _| menu.entry("Run", None, |_, _| {}))
            })
        });
        let dismissals = Rc::new(Cell::new(0));
        let _subscription = visual.update(|_, cx| {
            let dismissals = dismissals.clone();
            cx.subscribe(&menu, move |_, _: &DismissEvent, _| {
                dismissals.set(dismissals.get() + 1)
            })
        });
        menu.update_in(&mut visual, |menu, window, cx| {
            menu.select_first(&SelectFirst, window, cx)
        });
        open_selected_submenu(&menu, &mut visual);
        visual.dispatch_action(menu::Confirm);
        visual.run_until_parked();
        assert_eq!(dismissals.get(), 1);
    }

    struct EmbeddedTestView {
        focus_handle: FocusHandle,
        bounds: Rc<Cell<Option<Bounds<Pixels>>>>,
    }

    impl Render for EmbeddedTestView {
        fn render(&mut self, _: &mut Window, _: &mut Context<Self>) -> impl IntoElement {
            let bounds = self.bounds.clone();
            v_flex()
                .relative()
                .child(div().track_focus(&self.focus_handle).child("search field"))
                .child(div().h(px(40.)).child("results"))
                .child(
                    canvas(
                        move |element_bounds, _, _| bounds.set(Some(element_bounds)),
                        |_, _, _, _| {},
                    )
                    .size_full()
                    .absolute()
                    .top_0()
                    .left_0(),
                )
        }
    }

    #[gpui::test]
    fn submenu_opens_beside_its_trigger_on_either_side(cx: &mut TestAppContext) {
        cx.update(|cx| {
            let settings_store = settings::SettingsStore::test(cx);
            cx.set_global(settings_store);
            theme_settings::init(theme::LoadThemes::JustBase, cx);
        });

        for (left, opens_left) in [(px(40.), false), (px(460.), true)] {
            let window = cx.open_window(size(px(700.), px(400.)), |window, cx| {
                let menu = ContextMenu::build(window, cx, |menu, _, _| {
                    menu.submenu("First", |menu, _, _| {
                        menu.submenu("Nested", |menu, _, _| {
                            menu.entry("Submenu entry", None, |_, _| {})
                        })
                    })
                });
                SubmenuTestView { menu, left }
            });
            cx.run_until_parked();
            let menu = window
                .update(cx, |view, _, _| view.menu.clone())
                .expect("submenu window");
            let mut visual = VisualTestContext::from_window(window.into(), cx);

            visual.update(|window, cx| window.draw(cx).clear(cx));
            let trigger = menu.read_with(&visual, |menu, _| {
                menu.submenu_trigger_bounds
                    .borrow()
                    .get(&0)
                    .copied()
                    .expect("trigger bounds")
            });
            visual.simulate_mouse_move(trigger.center(), None, Modifiers::default());
            visual.update(|window, cx| window.draw(cx).clear(cx));

            menu.read_with(&visual, |menu, _| {
                let trigger = menu
                    .submenu_trigger_bounds
                    .borrow()
                    .get(&0)
                    .copied()
                    .expect("trigger bounds");
                let submenu = menu.submenu_bounds.get().expect("submenu bounds");
                assert_eq!(
                    submenu.top(),
                    trigger.top(),
                    "trigger: {trigger:?}, submenu: {submenu:?}"
                );
                if opens_left {
                    assert!(
                        submenu.right() <= trigger.left() + px(2.),
                        "trigger: {trigger:?}, submenu: {submenu:?}"
                    );
                    assert!(
                        submenu.right() >= trigger.left() - px(2.),
                        "trigger: {trigger:?}, submenu: {submenu:?}"
                    );
                } else {
                    assert!(
                        submenu.left() >= trigger.right() - px(2.),
                        "trigger: {trigger:?}, submenu: {submenu:?}"
                    );
                    assert!(
                        submenu.left() <= trigger.right() + px(2.),
                        "trigger: {trigger:?}, submenu: {submenu:?}"
                    );
                }
                assert!(submenu.left() >= px(8.));
                assert!(submenu.right() <= px(692.));
            });
            let submenu_center = menu.read_with(&visual, |menu, _| {
                menu.submenu_bounds.get().expect("submenu bounds").center()
            });
            visual.simulate_mouse_move(submenu_center, None, Modifiers::default());
            visual.update(|window, cx| window.draw(cx).clear(cx));

            let child = menu.read_with(&visual, |menu, _| match &menu.submenu_state {
                SubmenuState::Open(open_submenu) => open_submenu.entity.clone(),
                SubmenuState::Closed => panic!("submenu was closed"),
            });
            child.update_in(&mut visual, |child, window, cx| {
                child.select_first(&SelectFirst, window, cx);
                child.select_submenu_child(&SelectChild, window, cx);
            });
            visual.update(|window, cx| window.draw(cx).clear(cx));
            child.read_with(&visual, |child, _| {
                let trigger = child
                    .submenu_trigger_bounds
                    .borrow()
                    .get(&0)
                    .copied()
                    .expect("nested trigger bounds");
                let submenu = child.submenu_bounds.get().expect("nested submenu bounds");
                assert_eq!(child.submenu_depth, 1);
                assert_eq!(submenu.top(), trigger.top());
                assert!(submenu.left() >= px(8.));
                assert!(submenu.right() <= px(692.));
            });
        }
    }

    #[gpui::test]
    fn wide_submenu_opens_on_the_side_it_fits(cx: &mut TestAppContext) {
        cx.update(|cx| {
            let settings_store = settings::SettingsStore::test(cx);
            cx.set_global(settings_store);
            theme_settings::init(theme::LoadThemes::JustBase, cx);
        });

        let window = cx.open_window(size(px(900.), px(400.)), |window, cx| {
            let menu = ContextMenu::build(window, cx, |menu, _, _| {
                menu.submenu("Wide", |menu, _, _| {
                    menu.custom_row(|_, _| div().w(px(320.)).child("wide").into_any_element())
                })
            });
            SubmenuTestView {
                menu,
                left: px(400.),
            }
        });
        cx.run_until_parked();
        let menu = window
            .update(cx, |view, _, _| view.menu.clone())
            .expect("submenu window");
        let mut visual = VisualTestContext::from_window(window.into(), cx);
        draw_frames(&mut visual);

        menu.update_in(&mut visual, |menu, window, cx| {
            menu.select_first(&SelectFirst, window, cx);
            menu.select_submenu_child(&SelectChild, window, cx);
        });
        draw_frames(&mut visual);

        menu.read_with(&visual, |menu, _| {
            let trigger = menu
                .submenu_trigger_bounds
                .borrow()
                .get(&0)
                .copied()
                .expect("trigger bounds");
            let submenu = menu.submenu_bounds.get().expect("submenu bounds");
            let space_on_right = px(900.) - trigger.right();
            assert!(
                space_on_right > CONTEXT_MENU_MIN_WIDTH && space_on_right < submenu.size.width,
                "trigger: {trigger:?}, submenu: {submenu:?}"
            );
            assert_eq!(
                submenu.right(),
                trigger.left() + px(2.),
                "trigger: {trigger:?}, submenu: {submenu:?}"
            );
            assert_eq!(submenu.top(), trigger.top());
        });
    }

    #[gpui::test]
    fn submenu_content_keeps_focus(cx: &mut TestAppContext) {
        let content_focus = cx.update(|cx| cx.focus_handle());
        let (menu, mut visual) = open_window_with_submenu(cx, {
            let content_focus = content_focus.clone();
            move |menu, _, _| {
                let content_focus = content_focus.clone();
                menu.custom_row(move |_, _| {
                    div()
                        .track_focus(&content_focus)
                        .child("search field")
                        .into_any_element()
                })
            }
        });

        menu.update_in(&mut visual, |menu, window, cx| {
            menu.select_first(&SelectFirst, window, cx);
            menu.select_submenu_child(&SelectChild, window, cx);
        });
        draw_frames(&mut visual);
        visual.update(|window, cx| window.focus(&content_focus, cx));
        draw_frames(&mut visual);

        let content_is_focused = visual.update(|window, _| content_focus.is_focused(window));
        assert!(
            content_is_focused,
            "the menu must not move focus off content inside its open submenu"
        );
    }

    fn open_window_with_submenu(
        cx: &mut TestAppContext,
        build_submenu: impl Fn(ContextMenu, &mut Window, &mut Context<ContextMenu>) -> ContextMenu
        + 'static,
    ) -> (Entity<ContextMenu>, VisualTestContext) {
        cx.update(|cx| {
            let settings_store = settings::SettingsStore::test(cx);
            cx.set_global(settings_store);
            theme_settings::init(theme::LoadThemes::JustBase, cx);
        });

        let window = cx.open_window(size(px(700.), px(400.)), move |window, cx| {
            let menu = ContextMenu::build(window, cx, move |menu, _, _| {
                menu.submenu("Search", build_submenu)
            });
            SubmenuTestView {
                menu,
                left: px(40.),
            }
        });
        cx.run_until_parked();
        let menu = window
            .update(cx, |view, _, _| view.menu.clone())
            .expect("submenu window");
        let mut visual = VisualTestContext::from_window(window.into(), cx);
        draw_frames(&mut visual);
        (menu, visual)
    }

    fn open_window_with_embedded_view_submenu(
        content_focus: &FocusHandle,
        content_bounds: &Rc<Cell<Option<Bounds<Pixels>>>>,
        cx: &mut TestAppContext,
    ) -> (Entity<ContextMenu>, VisualTestContext) {
        let content_focus = content_focus.clone();
        let content_bounds = content_bounds.clone();
        open_window_with_submenu(cx, move |menu, _, cx| {
            let view = cx.new(|_| EmbeddedTestView {
                focus_handle: content_focus.clone(),
                bounds: content_bounds.clone(),
            });
            menu.embedded_view(view)
                .focus_content(content_focus.clone())
        })
    }

    fn draw_frames(cx: &mut VisualTestContext) {
        for _ in 0..3 {
            cx.update(|window, cx| window.draw(cx).clear(cx));
        }
    }

    fn submenu_trigger_bounds(
        menu: &Entity<ContextMenu>,
        index: usize,
        cx: &mut VisualTestContext,
    ) -> Bounds<Pixels> {
        menu.read_with(cx, |menu, _| {
            menu.submenu_trigger_bounds
                .borrow()
                .get(&index)
                .copied()
                .expect("trigger bounds")
        })
    }

    fn opened_submenu_index(
        menu: &Entity<ContextMenu>,
        cx: &mut VisualTestContext,
    ) -> Option<usize> {
        menu.read_with(cx, |menu, _| match &menu.submenu_state {
            SubmenuState::Open(open_submenu) => Some(open_submenu.item_index),
            SubmenuState::Closed => None,
        })
    }

    #[gpui::test]
    fn typing_with_pointer_on_submenu_trigger_keeps_submenu_open(cx: &mut TestAppContext) {
        let content_focus = cx.update(|cx| cx.focus_handle());
        let content_bounds = Rc::new(Cell::new(None));
        let (menu, mut visual) =
            open_window_with_embedded_view_submenu(&content_focus, &content_bounds, cx);
        let trigger = submenu_trigger_bounds(&menu, 0, &mut visual);

        visual.simulate_mouse_move(trigger.center(), None, Modifiers::default());
        draw_frames(&mut visual);
        visual.simulate_keystrokes("a b");
        draw_frames(&mut visual);

        assert_eq!(opened_submenu_index(&menu, &mut visual), Some(0));
        assert!(visual.update(|window, _| content_focus.is_focused(window)));
    }

    #[gpui::test]
    fn arrow_key_with_pointer_on_submenu_trigger_navigates_the_submenu(cx: &mut TestAppContext) {
        let (menu, mut visual) = open_window_with_submenu(cx, |menu, _, _| {
            menu.entry("A", None, |_, _| {}).entry("B", None, |_, _| {})
        });
        visual.update(|_, cx| {
            cx.bind_keys([gpui::KeyBinding::new("down", SelectNext, Some("menu"))])
        });
        let trigger = submenu_trigger_bounds(&menu, 0, &mut visual);

        visual.simulate_mouse_move(trigger.center(), None, Modifiers::default());
        draw_frames(&mut visual);
        visual.simulate_keystrokes("down");
        draw_frames(&mut visual);

        let submenu = menu
            .read_with(&visual, |menu, _| match &menu.submenu_state {
                SubmenuState::Open(open_submenu) => Some(open_submenu.entity.clone()),
                SubmenuState::Closed => None,
            })
            .expect("submenu stays open");
        let selected = submenu.read_with(&visual, |submenu, _| submenu.selected_index());
        assert_eq!(selected, Some(0));
        assert!(visual.update(|window, cx| submenu.focus_handle(cx).is_focused(window)));
    }

    #[gpui::test]
    fn pointer_leaving_submenu_trigger_after_keypress_closes_submenu(cx: &mut TestAppContext) {
        let (menu, mut visual) = open_window_with_submenu(cx, |menu, _, _| {
            menu.entry("A", None, |_, _| {}).entry("B", None, |_, _| {})
        });
        let trigger = submenu_trigger_bounds(&menu, 0, &mut visual);

        visual.simulate_mouse_move(trigger.center(), None, Modifiers::default());
        draw_frames(&mut visual);
        visual.simulate_keystrokes("a");
        draw_frames(&mut visual);
        assert_eq!(opened_submenu_index(&menu, &mut visual), Some(0));

        visual.simulate_mouse_move(point(px(680.), px(380.)), None, Modifiers::default());
        draw_frames(&mut visual);
        assert_eq!(opened_submenu_index(&menu, &mut visual), None);
    }

    #[gpui::test]
    fn opening_submenu_from_keyboard_focuses_its_content(cx: &mut TestAppContext) {
        let content_focus = cx.update(|cx| cx.focus_handle());
        let content_bounds = Rc::new(Cell::new(None));
        let (menu, mut visual) =
            open_window_with_embedded_view_submenu(&content_focus, &content_bounds, cx);

        menu.update_in(&mut visual, |menu, window, cx| {
            menu.select_first(&SelectFirst, window, cx);
            menu.select_submenu_child(&SelectChild, window, cx);
        });
        draw_frames(&mut visual);

        let content_is_focused = visual.update(|window, _| content_focus.is_focused(window));
        assert!(
            content_is_focused,
            "opening the submenu must focus its content"
        );
    }

    #[gpui::test]
    fn confirming_submenu_trigger_focuses_its_content(cx: &mut TestAppContext) {
        let content_focus = cx.update(|cx| cx.focus_handle());
        let content_bounds = Rc::new(Cell::new(None));
        let (menu, mut visual) =
            open_window_with_embedded_view_submenu(&content_focus, &content_bounds, cx);

        menu.update_in(&mut visual, |menu, window, cx| {
            menu.select_first(&SelectFirst, window, cx);
            menu.confirm(&menu::Confirm, window, cx);
        });
        draw_frames(&mut visual);

        let content_is_focused = visual.update(|window, _| content_focus.is_focused(window));
        assert!(
            content_is_focused,
            "confirming the submenu trigger must focus its content"
        );
    }

    #[gpui::test]
    fn clicking_embedded_view_outside_its_focus_keeps_content_focused(cx: &mut TestAppContext) {
        let content_focus = cx.update(|cx| cx.focus_handle());
        let content_bounds = Rc::new(Cell::new(None));
        let (menu, mut visual) =
            open_window_with_embedded_view_submenu(&content_focus, &content_bounds, cx);

        menu.update_in(&mut visual, |menu, window, cx| {
            menu.select_first(&SelectFirst, window, cx);
            menu.select_submenu_child(&SelectChild, window, cx);
        });
        draw_frames(&mut visual);
        let content_is_focused = visual.update(|window, _| content_focus.is_focused(window));
        assert!(
            content_is_focused,
            "opening the submenu focuses its content"
        );

        let view_bounds = content_bounds.get().expect("embedded view bounds");
        let results_area = point(view_bounds.left() + px(10.), view_bounds.bottom() - px(10.));
        visual.simulate_click(results_area, Modifiers::default());
        draw_frames(&mut visual);

        let submenu_is_open = menu.read_with(&visual, |menu, _| {
            matches!(menu.submenu_state, SubmenuState::Open(_))
        });
        let content_is_focused = visual.update(|window, _| content_focus.is_focused(window));
        assert!(submenu_is_open, "clicking inside the submenu keeps it open");
        assert!(
            content_is_focused,
            "clicking a part of the content that can't take focus must leave focus on the content"
        );
    }

    #[gpui::test]
    fn opening_submenu_by_hover_focuses_its_content(cx: &mut TestAppContext) {
        let content_focus = cx.update(|cx| cx.focus_handle());
        let content_bounds = Rc::new(Cell::new(None));
        let (menu, mut visual) =
            open_window_with_embedded_view_submenu(&content_focus, &content_bounds, cx);

        let trigger = menu.read_with(&visual, |menu, _| {
            menu.submenu_trigger_bounds
                .borrow()
                .get(&0)
                .copied()
                .expect("trigger bounds")
        });
        visual.simulate_mouse_move(trigger.center(), None, Modifiers::default());
        draw_frames(&mut visual);

        let content_is_focused = visual.update(|window, _| content_focus.is_focused(window));
        assert!(
            content_is_focused,
            "opening the submenu by hover must focus its content"
        );
    }

    fn focus_menu(menu: &Entity<ContextMenu>, cx: &mut VisualTestContext) {
        cx.update(|window, cx| window.blur(cx));
        cx.run_until_parked();
        cx.update(|window, cx| window.focus(&menu.focus_handle(cx), cx));
        cx.run_until_parked();
    }

    fn assert_focus_selection(cx: &mut TestAppContext, persistent: bool, a11y_enabled: bool) {
        if !a11y_enabled {
            cx.disable_accessibility();
        }
        cx.update(|cx| {
            let settings_store = settings::SettingsStore::test(cx);
            cx.set_global(settings_store);
            theme_settings::init(theme::LoadThemes::JustBase, cx);
        });

        let window = cx
            .update(|cx| {
                cx.open_window(Default::default(), |window, cx| {
                    let build_menu =
                        |menu: ContextMenu, _: &mut Window, _: &mut Context<ContextMenu>| {
                            menu.header("Options")
                                .entry("First", None, |_, _| {})
                                .separator()
                                .item(
                                    ContextMenuEntry::new("Checked")
                                        .toggleable(IconPosition::Start, true),
                                )
                        };
                    if persistent {
                        ContextMenu::build_persistent(window, cx, build_menu)
                    } else {
                        ContextMenu::build(window, cx, build_menu)
                    }
                })
            })
            .expect("open menu window");
        let menu = window.root(cx).expect("menu root");
        let mut cx = VisualTestContext::from_window(window.into(), cx);
        let focus_events = Rc::new(Cell::new(0));
        cx.update(|window, cx| {
            assert_eq!(window.is_a11y_enabled(), a11y_enabled);
            assert!(!window.is_a11y_active());
            let focus_events = focus_events.clone();
            window
                .on_focus_in(&menu.focus_handle(cx), cx, move |_, _| {
                    focus_events.set(focus_events.get() + 1);
                })
                .detach();
            window.activate_window();
        });
        cx.run_until_parked();

        menu.read_with(&cx, |menu, _| {
            assert_eq!(menu.selected_index, None);
            assert_eq!(menu.suppress_focus_selection, !a11y_enabled);
        });
        focus_menu(&menu, &mut cx);
        assert_eq!(focus_events.get(), 1);
        assert_eq!(
            menu.read_with(&cx, |menu, _| menu.selected_index),
            a11y_enabled.then_some(3),
        );

        cx.dispatch_action(SelectNext);
        assert_eq!(
            menu.read_with(&cx, |menu, _| menu.selected_index),
            Some(1),
            "SelectNext right after opening should select the first selectable entry",
        );
        cx.dispatch_action(SelectNext);
        assert_eq!(menu.read_with(&cx, |menu, _| menu.selected_index), Some(3));
        cx.dispatch_action(SelectPrevious);
        assert_eq!(menu.read_with(&cx, |menu, _| menu.selected_index), Some(1));

        focus_menu(&menu, &mut cx);
        assert_eq!(focus_events.get(), 2);
        assert_eq!(menu.read_with(&cx, |menu, _| menu.selected_index), Some(1));

        menu.update(&mut cx, |menu, cx| {
            menu.clear_selected();
            if a11y_enabled {
                menu.suppress_focus_selection = true;
            }
            cx.notify();
        });
        focus_menu(&menu, &mut cx);
        assert_eq!(focus_events.get(), 3);
        menu.read_with(&cx, |menu, _| {
            assert_eq!(menu.selected_index, None);
            assert_eq!(menu.suppress_focus_selection, !a11y_enabled);
        });

        focus_menu(&menu, &mut cx);
        assert_eq!(focus_events.get(), 4);
        assert_eq!(
            menu.read_with(&cx, |menu, _| menu.selected_index),
            a11y_enabled.then_some(3),
        );
    }

    #[gpui::test]
    fn focus_selection_with_accessibility(cx: &mut TestAppContext) {
        assert_focus_selection(cx, false, true);
    }

    #[gpui::test]
    fn focus_selection_without_accessibility(cx: &mut TestAppContext) {
        assert_focus_selection(cx, false, false);
    }

    #[gpui::test]
    fn persistent_focus_selection_with_accessibility(cx: &mut TestAppContext) {
        assert_focus_selection(cx, true, true);
    }

    #[gpui::test]
    fn persistent_focus_selection_without_accessibility(cx: &mut TestAppContext) {
        assert_focus_selection(cx, true, false);
    }

    #[gpui::test]
    fn confirm_without_selection_dismisses(cx: &mut TestAppContext) {
        let cx = cx.add_empty_window();
        let entry_handler_calls = Rc::new(Cell::new(0));
        let context_menu = cx.update(|window, cx| {
            ContextMenu::build(window, cx, {
                let entry_handler_calls = entry_handler_calls.clone();
                move |menu, _, _| {
                    menu.header("Header").entry("Entry", None, move |_, _| {
                        entry_handler_calls.set(entry_handler_calls.get() + 1);
                    })
                }
            })
        });

        let dismiss_events = Rc::new(Cell::new(0));
        let _subscription = cx.update(|_, cx| {
            let dismiss_events = dismiss_events.clone();
            cx.subscribe(&context_menu, move |_, _: &DismissEvent, _| {
                dismiss_events.set(dismiss_events.get() + 1);
            })
        });

        context_menu.update_in(cx, |context_menu, window, cx| {
            assert_eq!(None, context_menu.selected_index);
            context_menu.confirm(&menu::Confirm, window, cx);
        });
        cx.run_until_parked();

        assert_eq!(
            dismiss_events.get(),
            1,
            "Confirming without a selection should dismiss the menu"
        );
        assert_eq!(
            entry_handler_calls.get(),
            0,
            "Confirming without a selection should not trigger any entry"
        );
    }

    #[gpui::test]
    fn can_navigate_back_over_headers(cx: &mut TestAppContext) {
        let cx = cx.add_empty_window();
        let context_menu = cx.update(|window, cx| {
            ContextMenu::build(window, cx, |menu, _, _| {
                menu.header("First header")
                    .separator()
                    .entry("First entry", None, |_, _| {})
                    .separator()
                    .separator()
                    .entry("Last entry", None, |_, _| {})
                    .header("Last header")
            })
        });

        context_menu.update_in(cx, |context_menu, window, cx| {
            assert_eq!(
                None, context_menu.selected_index,
                "No selection is in the menu initially"
            );

            context_menu.select_first(&SelectFirst, window, cx);
            assert_eq!(
                Some(2),
                context_menu.selected_index,
                "Should select first selectable entry, skipping the header and the separator"
            );

            context_menu.select_next(&SelectNext, window, cx);
            assert_eq!(
                Some(5),
                context_menu.selected_index,
                "Should select next selectable entry, skipping 2 separators along the way"
            );

            context_menu.select_next(&SelectNext, window, cx);
            assert_eq!(
                Some(2),
                context_menu.selected_index,
                "Should wrap around to first selectable entry"
            );
        });

        context_menu.update_in(cx, |context_menu, window, cx| {
            assert_eq!(
                Some(2),
                context_menu.selected_index,
                "Should start from the first selectable entry"
            );

            context_menu.select_previous(&SelectPrevious, window, cx);
            assert_eq!(
                Some(5),
                context_menu.selected_index,
                "Should wrap around to previous selectable entry (last)"
            );

            context_menu.select_previous(&SelectPrevious, window, cx);
            assert_eq!(
                Some(2),
                context_menu.selected_index,
                "Should go back to previous selectable entry (first)"
            );
        });

        context_menu.update_in(cx, |context_menu, window, cx| {
            context_menu.select_first(&SelectFirst, window, cx);
            assert_eq!(
                Some(2),
                context_menu.selected_index,
                "Should start from the first selectable entry"
            );

            context_menu.select_previous(&SelectPrevious, window, cx);
            assert_eq!(
                Some(5),
                context_menu.selected_index,
                "Should wrap around to last selectable entry"
            );
            context_menu.select_next(&SelectNext, window, cx);
            assert_eq!(
                Some(2),
                context_menu.selected_index,
                "Should wrap around to first selectable entry"
            );
        });
    }
}