use std::{
hash::{DefaultHasher, Hash, Hasher},
sync::Arc,
};
use parking_lot::Mutex;
use crate::{
app::events::{KeyboardEvent, MouseEvent},
core::{ElementRef, Signal},
layout::layout_kind::ScrollState,
ui::{shared::command_held_key, toolbar::keyboard_click},
};
type Action = Arc<dyn Fn() + Send + Sync>;
pub(crate) type Aside = Arc<dyn Fn(&MouseEvent) + Send + Sync>;
#[derive(Clone, Default)]
struct Row {
choose: Option<Action>,
aside: Option<Aside>,
}
#[derive(Default)]
struct Held {
open: bool,
seen: Option<u64>,
choosable: Vec<bool>,
active: Option<usize>,
rows: Vec<Row>,
dismiss: Option<Action>,
in_section: Vec<Option<usize>>,
holders: Vec<ElementRef>,
sections: Vec<(ScrollState, ElementRef)>,
}
#[derive(Clone)]
pub struct MenuKeys {
field: ElementRef,
held: Arc<Mutex<Held>>,
tick: Signal<u64>,
}
impl MenuKeys {
pub fn new(field: impl Into<ElementRef>) -> Self {
Self {
field: field.into(),
held: Arc::default(),
tick: Signal::new(0),
}
}
pub fn field(&self) -> &ElementRef {
&self.field
}
pub fn active(&self) -> Option<usize> {
self.held.lock().active
}
pub fn key_down(&self, event: &KeyboardEvent) -> bool {
if event.default_prevented() || event.composing || event.alt {
return false;
}
let command = command_held_key(event);
let plain = !event.ctrl && !event.meta;
let taken = match event.key.as_str() {
"ArrowDown" | "ArrowUp" if plain && !event.shift => self.step(event.key == "ArrowDown"),
"Enter" if command => self.aside(event),
"Enter" if plain && !event.shift => self.choose(),
"Escape" if plain => self.dismiss(),
_ => false,
};
if taken {
event.prevent_default();
}
taken
}
fn step(&self, forward: bool) -> bool {
let mut held = self.held.lock();
let count = held.choosable.len();
if !held.open || !held.choosable.contains(&true) {
return false;
}
let at = held.active.unwrap_or(if forward { count - 1 } else { 0 });
let next = (1..=count)
.map(|step| {
if forward {
(at + step) % count
} else {
(at + count - step) % count
}
})
.find(|index| held.choosable[*index]);
held.active = next;
if let Some(next) = next {
held.reveal(next);
}
drop(held);
self.redraw();
true
}
fn choose(&self) -> bool {
let choose = {
let held = self.held.lock();
let Some(at) = held.active.filter(|_| held.open) else {
return false;
};
held.rows.get(at).and_then(|row| row.choose.clone())
};
let Some(choose) = choose else {
return false;
};
choose();
true
}
fn aside(&self, event: &KeyboardEvent) -> bool {
let aside = {
let held = self.held.lock();
let Some(at) = held.active.filter(|_| held.open) else {
return false;
};
held.rows.get(at).and_then(|row| row.aside.clone())
};
let Some(aside) = aside else {
return false;
};
let mut press = keyboard_click();
(press.shift, press.ctrl, press.meta) = (event.shift, event.ctrl, event.meta);
aside(&press);
true
}
fn dismiss(&self) -> bool {
let dismiss = {
let held = self.held.lock();
held.dismiss.clone().filter(|_| held.open)
};
let Some(dismiss) = dismiss else {
return false;
};
dismiss();
true
}
fn redraw(&self) {
self.tick.update(|tick| *tick = tick.wrapping_add(1));
}
pub(crate) fn point(&self, index: usize) {
let mut held = self.held.lock();
if held.active == Some(index) || !held.choosable.get(index).copied().unwrap_or(false) {
return;
}
held.active = Some(index);
drop(held);
self.redraw();
}
pub(crate) fn begin(&self, open: bool, items: &[(&str, bool)], dismiss: Action) -> Option<usize> {
self.tick.get();
let mut held = self.held.lock();
held.rows = vec![Row::default(); items.len()];
held.in_section = vec![None; items.len()];
held.dismiss = Some(dismiss);
if !open {
(held.open, held.seen, held.active) = (false, None, None);
held.choosable.clear();
return None;
}
let mut hasher = DefaultHasher::new();
items.hash(&mut hasher);
let seen = hasher.finish();
held.choosable = items.iter().map(|(_, choosable)| *choosable).collect();
let first = held.choosable.iter().position(|choosable| *choosable);
let kept = held
.active
.filter(|at| held.open && held.seen == Some(seen) && held.choosable.get(*at).copied().unwrap_or(false));
if kept.is_none() {
for (scroll, _) in &held.sections {
if scroll.scroll_y() != 0.0 {
scroll.set_scroll_pending(scroll.scroll_x(), 0.0);
}
}
}
held.active = kept.or(first);
(held.open, held.seen) = (true, Some(seen));
held.active
}
pub(crate) fn section(&self, section: usize) -> (ScrollState, ElementRef) {
let mut held = self.held.lock();
while held.sections.len() <= section {
held.sections.push((ScrollState::new(), ElementRef::new()));
}
held.sections[section].clone()
}
pub(crate) fn in_section(&self, index: usize, section: usize) -> ElementRef {
let mut held = self.held.lock();
if let Some(at) = held.in_section.get_mut(index) {
*at = Some(section);
}
while held.holders.len() <= index {
held.holders.push(ElementRef::new());
}
held.holders[index].clone()
}
pub(crate) fn register(&self, index: usize, choose: Option<Action>, aside: Option<Aside>) {
if let Some(row) = self.held.lock().rows.get_mut(index) {
*row = Row { choose, aside };
}
}
}
impl Held {
fn reveal(&self, index: usize) {
let Some(Some(section)) = self.in_section.get(index) else {
return;
};
let (Some((scroll, view)), Some(row)) = (self.sections.get(*section), self.holders.get(index)) else {
return;
};
let (view, row) = (view.bounds(), row.bounds());
if view.height <= 0.0 || row.height <= 0.0 {
return;
}
let by = if row.y < view.y {
row.y - view.y
} else if row.y + row.height > view.y + view.height {
row.y + row.height - view.y - view.height
} else {
return;
};
scroll.set_scroll_pending(scroll.scroll_x(), (scroll.scroll_y() + by).max(0.0));
}
}
#[derive(Clone)]
pub(crate) struct ItemKeys {
pub(crate) keys: MenuKeys,
pub(crate) index: usize,
pub(crate) active: bool,
}