use std::{
cell::RefCell,
collections::HashMap,
sync::{Arc, LazyLock, Mutex, Weak},
};
use super::{
menu::{Closer, Menu, MenuEntry, MenuItem, MenuItemPart, MenuPart},
names,
recipe::{Case, Name, Recipe, ResolvedPart, ResolvedRecipe},
separator::Separator,
theme::{Themed, current_theme},
};
use crate::{
app::{
ctx::CollisionStrategy,
events::{KeyboardEvent, LongPressEvent, MouseButton, MouseEvent},
theme::{BorderSize, PaletteColor, RadiusSize, ShadowStyle, Theme},
},
components::{Popup, Row},
core::{ElementRef, Signal},
layout::{Alignment, layout_kind::LayoutKind},
node::{Element, FocusGroup, Node, NodeUpdate, SpacingValue, border::Border},
};
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
pub enum ContextMenuPart {
Panel,
Bar,
BarItem,
BarLabel,
}
names!(ContextMenuPart {
Panel => "panel",
Bar => "bar",
BarItem => "bar_item",
BarLabel => "bar_label",
});
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
pub enum ContextMenuState {
Bar,
}
names!(ContextMenuState {
Bar => "bar",
});
pub type ContextMenuRenderer = Arc<dyn Fn(ContextMenuView) -> Element + Send + Sync>;
struct Kept {
point: Signal<Option<(f32, f32)>>,
anchor: ElementRef,
alive: Weak<()>,
}
static KEPT: LazyLock<Mutex<HashMap<usize, Kept>>> = LazyLock::new(Default::default);
fn kept(open: usize) -> (Signal<Option<(f32, f32)>>, ElementRef, Arc<()>) {
let mut all = KEPT.lock().unwrap();
all.retain(|_, kept| kept.alive.strong_count() > 0);
if let Some(kept) = all.get(&open)
&& let Some(alive) = kept.alive.upgrade()
{
return (kept.point.clone(), kept.anchor.clone(), alive);
}
let (point, anchor, alive) = (Signal::new(None), ElementRef::new(), Arc::new(()));
all.insert(
open,
Kept {
point: point.clone(),
anchor: anchor.clone(),
alive: Arc::downgrade(&alive),
},
);
(point, anchor, alive)
}
thread_local! {
static OPEN: RefCell<Option<Signal<bool>>> = const { RefCell::new(None) };
}
fn take_turn(open: &Signal<bool>) {
let before = OPEN.with(|last| last.borrow_mut().replace(open.clone()));
if let Some(before) = before
&& before.id() != open.id()
&& before.get_untracked()
{
before.set(false);
}
open.set(true);
}
pub struct ContextMenu {
target: Element,
open: Signal<bool>,
entries: Vec<MenuEntry>,
bar: bool,
disabled: bool,
inline: bool,
label: Option<Arc<str>>,
on_dismiss: Vec<Arc<dyn Fn() + Send + Sync>>,
dismiss_on_escape: bool,
dismiss_on_outside_press: bool,
offset: Option<SpacingValue>,
collision: Option<CollisionStrategy>,
states: Vec<Name>,
rules: Recipe,
id: Option<Arc<str>>,
key: Option<Arc<str>>,
}
impl ContextMenu {
pub fn new(open: Signal<bool>, target: impl Into<Element>) -> Self {
Self {
target: target.into(),
open,
entries: Vec::new(),
bar: false,
disabled: false,
inline: false,
label: None,
on_dismiss: Vec::new(),
dismiss_on_escape: true,
dismiss_on_outside_press: true,
offset: None,
collision: None,
states: Vec::new(),
rules: Recipe::new(),
id: None,
key: None,
}
}
pub fn item(mut self, item: MenuItem) -> Self {
self.entries.push(MenuEntry::Item(item));
self
}
pub fn items(mut self, items: impl IntoIterator<Item = MenuItem>) -> Self {
self.entries.extend(items.into_iter().map(MenuEntry::Item));
self
}
pub fn separator(mut self) -> Self {
self.entries.push(MenuEntry::Separator);
self
}
pub fn heading(mut self, heading: &str) -> Self {
self.entries.push(MenuEntry::Heading(Arc::from(heading)));
self
}
pub fn label(mut self, label: &str) -> Self {
self.label = Some(Arc::from(label));
self
}
pub fn inline(mut self, inline: bool) -> Self {
self.inline = inline;
self
}
pub fn on_dismiss(mut self, handler: impl Fn() + Send + Sync + 'static) -> Self {
self.on_dismiss.push(Arc::new(handler));
self
}
pub fn dismiss_on_escape(mut self, dismiss: bool) -> Self {
self.dismiss_on_escape = dismiss;
self
}
pub fn dismiss_on_outside_press(mut self, dismiss: bool) -> Self {
self.dismiss_on_outside_press = dismiss;
self
}
pub fn offset(mut self, offset: impl Into<SpacingValue>) -> Self {
self.offset = Some(offset.into());
self
}
pub fn collision(mut self, collision: CollisionStrategy) -> Self {
self.collision = Some(collision);
self
}
pub fn bar(mut self, bar: bool) -> Self {
self.bar = bar;
self
}
pub fn disabled(mut self, disabled: bool) -> Self {
self.disabled = disabled;
self
}
pub fn state(mut self, state: impl Into<Name>, on: bool) -> Self {
let state = state.into();
self.states.retain(|held| *held != state);
if on {
self.states.push(state);
}
self
}
pub fn style(mut self, part: impl Into<Name>, style: impl FnOnce(super::PartStyle) -> super::PartStyle) -> Self {
self.rules = self.rules.base(part, style);
self
}
pub fn rules(mut self, rules: &Recipe) -> Self {
self.rules = self.rules.extend(rules);
self
}
pub fn id(mut self, id: impl Into<Arc<str>>) -> Self {
self.id = Some(id.into());
self
}
pub fn key(mut self, key: impl Into<Arc<str>>) -> Self {
self.key = Some(key.into());
self
}
pub fn build(self, theme: &Theme) -> Element {
if self.disabled {
return self.target;
}
let case = Case {
variant: None,
size: None,
density: None,
breakpoint: super::current_breakpoint(),
states: self.states.clone(),
}
.state(ContextMenuState::Bar, self.bar);
let (point, kept_anchor, alive) = kept(self.open.id());
let target = holds_children(self.target);
let anchor = target.node.element_ref.clone().unwrap_or(kept_anchor);
let view = ContextMenuView {
entries: self.entries,
bar: self.bar,
inline: self.inline,
label: self.label,
on_dismiss: self.on_dismiss,
dismiss_on_escape: self.dismiss_on_escape,
dismiss_on_outside_press: self.dismiss_on_outside_press,
offset: self.offset,
collision: self.collision,
point: if self.open.get() { point.get() } else { None },
recipe: theme
.resolve::<ContextMenu>(&case, Some(&self.rules))
.owned_by(self.id.as_ref()),
target: Some(target),
anchor,
open: self.open,
asked_at: point,
alive,
id: self.id,
key: self.key,
};
match theme.renderer::<ContextMenu>() {
Some(renderer) => renderer(view),
None => view.render(),
}
}
}
impl From<ContextMenu> for Element {
fn from(menu: ContextMenu) -> Self {
menu.build(¤t_theme())
}
}
fn holds_children(element: Element) -> Element {
match element.node.layout_kind() {
LayoutKind::Row { .. } | LayoutKind::Column { .. } | LayoutKind::Stack { .. } | LayoutKind::Grid(_) => element,
_ => Row::new().child(element).into(),
}
}
pub struct ContextMenuView {
pub entries: Vec<MenuEntry>,
pub bar: bool,
pub inline: bool,
pub label: Option<Arc<str>>,
on_dismiss: Vec<Arc<dyn Fn() + Send + Sync>>,
dismiss_on_escape: bool,
dismiss_on_outside_press: bool,
offset: Option<SpacingValue>,
collision: Option<CollisionStrategy>,
pub point: Option<(f32, f32)>,
pub recipe: ResolvedRecipe,
target: Option<Element>,
anchor: ElementRef,
open: Signal<bool>,
asked_at: Signal<Option<(f32, f32)>>,
alive: Arc<()>,
id: Option<Arc<str>>,
key: Option<Arc<str>>,
}
impl ContextMenuView {
pub fn part(&self, part: impl Into<Name>) -> ResolvedPart {
self.recipe.part(part)
}
pub fn theme(&self) -> &Theme {
self.recipe.theme()
}
pub fn open(&self) -> &Signal<bool> {
&self.open
}
fn opener(&self) -> impl Fn(Option<(f32, f32)>) + Send + Sync + Clone + 'static {
let (open, asked_at, alive) = (self.open.clone(), self.asked_at.clone(), self.alive.clone());
move |point| {
let _ = &alive;
asked_at.set(point);
take_turn(&open);
}
}
fn menu(&mut self) -> Element {
let mut menu = Menu::new(self.open.clone(), self.anchor.clone())
.context(self.point)
.inline(self.inline)
.dismiss_on_escape(self.dismiss_on_escape)
.dismiss_on_outside_press(self.dismiss_on_outside_press)
.rules(&self.recipe.rules_for(ContextMenuPart::Panel, MenuPart::Panel));
for handler in &self.on_dismiss {
let handler = handler.clone();
menu = menu.on_dismiss(move || handler());
}
if let Some(label) = &self.label {
menu = menu.label(label);
}
if let Some(offset) = self.offset {
menu = menu.offset(offset);
}
if let Some(collision) = self.collision {
menu = menu.collision(collision);
}
for entry in std::mem::take(&mut self.entries) {
menu = menu.entry(entry);
}
if let Some(id) = &self.id {
menu = menu.id(id.clone());
}
if let Some(key) = &self.key {
menu = menu.key(key.clone());
}
menu.build(self.theme())
}
fn bar(&mut self) -> Element {
let item_rules = self
.recipe
.rules_for(ContextMenuPart::BarItem, MenuItemPart::Root)
.extend(&self.recipe.rules_for(ContextMenuPart::BarLabel, MenuItemPart::Label));
let mut panel = Row::new()
.align_items(Alignment::Stretch)
.part(&self.part(ContextMenuPart::Bar))
.focus_group(FocusGroup::horizontal().one_stop(true).follow_pointer(true))
.describe("a11y_role", "menu")
.describe("a11y_orientation", "horizontal");
if let Some(label) = &self.label {
panel = panel.describe("a11y_name", label.clone());
}
if let Some(id) = &self.id {
panel = panel.id(id.clone());
}
let dismissed = {
let handlers = self.on_dismiss.clone();
move || {
for handler in &handlers {
handler();
}
}
};
let close = Closer {
close: {
let open = self.open.clone();
Arc::new(move || open.set(false))
},
dismissed: Arc::new(dismissed.clone()),
};
for entry in bar_entries(std::mem::take(&mut self.entries)) {
panel = match entry {
MenuEntry::Item(item) => panel.child(
item
.named_by(&self.recipe, ContextMenuPart::BarItem)
.rules(&item_rules)
.in_menu(vec![close.clone()], Vec::new())
.build(self.theme()),
),
MenuEntry::Separator => panel.child(
Separator::vertical()
.rules(&self.recipe.lend("separator"))
.build(self.theme()),
),
MenuEntry::Heading(_) | MenuEntry::Scroll { .. } => panel,
MenuEntry::Element(element) => panel.child(element),
};
}
if let Some(key) = &self.key {
panel = panel.key(key.clone());
}
{
let (open, dismissed) = (self.open.clone(), dismissed.clone());
panel = panel.on_key_down(move |event: KeyboardEvent| {
if event.focus_within && event.key == "Tab" && !event.ctrl && !event.alt && !event.meta {
open.set(false);
dismissed();
}
});
}
if self.inline {
return panel.into();
}
let gap = self
.offset
.map_or(0.0, |offset| offset.resolve(&self.theme().spacing(), 0.0));
let (x, y) = (gap, gap);
let mut popup = Popup::new(self.anchor.clone(), panel)
.open(self.open.clone())
.at(self.point)
.offset(x, y)
.switch_on_anchor_press(false)
.takes_focus(true)
.dismiss_on_escape(self.dismiss_on_escape)
.dismiss_on_outside_click(self.dismiss_on_outside_press)
.on_dismiss(dismissed);
if let Some(collision) = self.collision {
popup = popup.collision(collision);
}
popup.into()
}
fn dress(
node: Node,
anchor: &ElementRef,
open: impl Fn(Option<(f32, f32)>) + Send + Sync + Clone + 'static,
menu: &Mutex<Element>,
) -> Node {
let mut node = node.ref_element(anchor.clone());
{
let open = open.clone();
NodeUpdate::on_mouse_click(&mut node, MouseButton::Right, move |event: MouseEvent| {
event.stop_propagation();
open(Some((event.x, event.y)));
});
}
if cfg!(target_os = "macos") {
let open = open.clone();
NodeUpdate::on_click(&mut node, move |event: MouseEvent| {
if event.ctrl && !event.from_keyboard {
event.stop_propagation();
event.prevent_default();
open(Some((event.x, event.y)));
}
});
}
{
let open = open.clone();
NodeUpdate::on_long_press(&mut node, move |event: LongPressEvent| {
event.stop_propagation();
open(Some((event.x, event.y)));
});
}
NodeUpdate::on_key_down(&mut node, move |event: KeyboardEvent| {
let asked = event.key == "ContextMenu" || (event.shift && event.key == "F10");
if event.focus_within && asked && !event.ctrl && !event.alt && !event.meta {
event.prevent_default();
open(None);
}
});
NodeUpdate::describe(&mut node, Arc::from("a11y_haspopup"), Arc::from("menu"));
NodeUpdate::child(&mut node, menu.lock().unwrap().clone().into_node());
node
}
pub fn render(mut self) -> Element {
let menu = if self.bar { self.bar() } else { self.menu() };
if self.inline {
return menu;
}
let menu = Arc::new(Mutex::new(menu));
let target = self.target.take().unwrap_or_else(Element::new);
let (anchor, open) = (self.anchor.clone(), self.opener());
target.decorate_root(move |node| Self::dress(node, &anchor, open.clone(), &menu))
}
}
impl crate::ui::Styled for ContextMenu {
type Component = Self;
fn rules(self, rules: &crate::ui::Recipe) -> Self {
Self::rules(self, rules)
}
fn state(self, state: impl Into<crate::ui::Name>, on: bool) -> Self {
Self::state(self, state, on)
}
}
impl Themed for ContextMenu {
const NAME: &'static str = "context_menu";
const ROOT: &'static str = "bar";
type Renderer = ContextMenuRenderer;
fn parts() -> crate::ui::Declared {
ContextMenuPart::declared()
}
fn states() -> crate::ui::Declared {
ContextMenuState::declared()
}
fn recipe() -> Recipe {
use ContextMenuPart::{Bar, BarItem, BarLabel, Panel};
use PaletteColor::{Popover, PopoverForeground};
Recipe::new()
.base(Panel, |s| s.min_width(220.0))
.base(Bar, |s| {
s.padding_x(3.0)
.padding_y(3.0)
.radius(RadiusSize::Lg)
.background(Popover)
.foreground(PopoverForeground)
.border(Border::inside(BorderSize::Sm, PaletteColor::Border))
.shadow(ShadowStyle::Lg)
})
.base(BarItem, |s| s.height(28.0).padding_x(10.0))
.base(BarLabel, |s| s.font_size(13.0))
}
}
fn bar_entries(entries: Vec<MenuEntry>) -> Vec<MenuEntry> {
entries
.into_iter()
.flat_map(|entry| match entry {
MenuEntry::Scroll { entries, .. } => bar_entries(entries),
entry => vec![entry],
})
.collect()
}