neuwirth
/
pmacs
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
pmacs/src/menu.rs

625 lines
21 KiB
Rust
Raw Blame History

// menu.rs --- Menu registry: the items that populate the right-click context menu.
//! Context-menu items.
//!
//! The right-click context menu (Q#CM2) is populated from a Lua
//! registry that mirrors [`crate::command::CommandRegistry`]. Each
//! [`MenuItem`] names a [`crate::command::Command`] to invoke and
//! carries optional visibility controls: a coarse `context` tag
//! (sugar) and/or a full `predicate` (the escape hatch), evaluated
//! against a context table when the menu opens (Q#CM3). Items are
//! grouped and ordered for layout; separators fall between groups.
//!
//! # Storage and lookup
//!
//! [`MenuRegistry`] owns the live items in insertion order. Unlike
//! commands, items are not uniquely *named* --- two contexts may each
//! contribute a "Copy". An optional `id` allows targeted removal or
//! in-place replacement, so a user config can hide or override a
//! builtin item (`pmacs.menu.remove("edit.copy")`, or re-`item` with
//! the same `id`) without disturbing the rest of the menu.
//!
//! # Threading
//!
//! Single-threaded, behind `Rc<RefCell<...>>` next to the command and
//! keymap registries.
use mlua::Function;
use thiserror::Error;
use crate::command::SourceLocation;
// ---------------------------------------------------------------------------
// Contexts
// ---------------------------------------------------------------------------
/// Coarse context tags that are sugar for a visibility predicate
/// (Q#CM3). Validated at registration so a typo (`"selecton"`) is a
/// hard error rather than a silently invisible item --- the same
/// typo-paranoia as the command spec's unknown-field check (R50).
///
/// The tag → predicate mapping is owned by the menu builder in the
/// core (it has the live context table); the registry only validates
/// the vocabulary.
pub const KNOWN_CONTEXTS: &[&str] = &["always", "selection", "symbol", "diagnostic"];
// ---------------------------------------------------------------------------
// MenuItem + errors
// ---------------------------------------------------------------------------
/// A single context-menu entry.
///
/// Cloning is cheap: `String`s clone trivially and `mlua::Function` is
/// reference-counted internally.
#[derive(Clone)]
pub struct MenuItem {
/// Optional stable identifier. Enables targeted [`MenuRegistry::remove`]
/// and in-place override (re-adding with the same id replaces).
pub id: Option<String>,
/// Human-readable label shown in the menu row.
pub label: String,
/// Name of the [`crate::command::Command`] this item invokes.
/// Resolved at invoke time (like a keymap binding), not at
/// registration --- the command may be defined later.
pub command: String,
/// Coarse visibility tag (one of [`KNOWN_CONTEXTS`]). Sugar for a
/// predicate; ignored when `predicate` is set.
pub context: Option<String>,
/// Full visibility predicate: `fn(context_table) -> bool`. The
/// escape hatch for items whose availability the coarse tags can't
/// express. Takes precedence over `context`.
pub predicate: Option<Function>,
/// Layout group. Items sharing a group render together; a separator
/// falls between distinct groups (group first-appearance order).
pub group: String,
/// Sort key within a group (ascending). Ties break on insertion order.
pub order: i64,
/// Where the item was defined (Lua `file:line`).
pub source: SourceLocation,
}
/// Errors raised by the menu registry.
#[derive(Debug, Error)]
pub enum MenuError {
/// `item` was called with no label or an all-whitespace one.
#[error("menu item label must be non-empty")]
EmptyLabel,
/// `item` was called without a `command` to invoke.
#[error("menu item \"{label}\" requires a non-empty `command`")]
EmptyCommand {
/// The offending item's label.
label: String,
},
/// The `context` tag is not one of [`KNOWN_CONTEXTS`].
#[error(
"menu item \"{label}\" has unknown context `{context}`; supported: always, selection, symbol, diagnostic"
)]
UnknownContext {
/// The offending item's label.
label: String,
/// The offending context tag.
context: String,
},
/// The spec table contained a key the registry doesn't know about.
#[error(
"unknown field `{field}` in menu item spec; supported: id, label, command, context, predicate, group, order"
)]
UnknownField {
/// The offending key.
field: String,
},
}
// ---------------------------------------------------------------------------
// MenuRegistry
// ---------------------------------------------------------------------------
/// Ordered registry of context-menu items.
///
/// Insert via [`Self::add`] (validates, replacing in place on a
/// matching `id`). Read the live set via [`Self::items`]; the menu
/// builder sorts and groups at open time. Remove by id via
/// [`Self::remove`]; reset via [`Self::clear`].
#[derive(Default)]
pub struct MenuRegistry {
items: Vec<MenuItem>,
}
impl MenuRegistry {
/// An empty registry.
#[must_use]
pub fn new() -> Self {
Self::default()
}
/// Insert `item`, validating its metadata. If the item carries an
/// `id` already present, the existing entry is replaced in place
/// (preserving its slot) so re-running config and user overrides are
/// idempotent; otherwise the item is appended.
pub fn add(&mut self, item: MenuItem) -> Result<(), MenuError> {
if item.label.trim().is_empty() {
return Err(MenuError::EmptyLabel);
}
if item.command.trim().is_empty() {
return Err(MenuError::EmptyCommand { label: item.label });
}
if let Some(context) = &item.context
&& !KNOWN_CONTEXTS.contains(&context.as_str())
{
return Err(MenuError::UnknownContext {
label: item.label,
context: context.clone(),
});
}
if let Some(id) = item.id.clone()
&& let Some(slot) = self
.items
.iter_mut()
.find(|it| it.id.as_deref() == Some(&id))
{
*slot = item;
return Ok(());
}
self.items.push(item);
Ok(())
}
/// The live items, in insertion order.
#[must_use]
pub fn items(&self) -> &[MenuItem] {
&self.items
}
/// Remove every item whose `id` equals `id`. Returns `true` if any
/// item was removed.
pub fn remove(&mut self, id: &str) -> bool {
let before = self.items.len();
self.items.retain(|it| it.id.as_deref() != Some(id));
self.items.len() != before
}
/// Drop every item.
pub fn clear(&mut self) {
self.items.clear();
}
/// Number of registered items.
#[must_use]
pub fn len(&self) -> usize {
self.items.len()
}
/// True iff no items are registered.
#[must_use]
pub fn is_empty(&self) -> bool {
self.items.is_empty()
}
}
// ---------------------------------------------------------------------------
// Open-menu runtime state (Q#CM1) + TUI surface
// ---------------------------------------------------------------------------
use std::sync::{Arc, Mutex};
use crate::buffer::Buffer;
use crate::cell::{CellCoord, CellGrid, Color, Glyph, Style};
use crate::view::{View, Viewport};
/// One rendered row of an open menu: either a selectable command or a
/// non-selectable group divider. The resolved list is built in Lua
/// (`pmacs.menu.build`, which evaluates predicates / context tags and
/// groups items) and stored here; navigation skips `Separator` rows.
#[derive(Clone, Debug, PartialEq, Eq)]
pub enum MenuRow {
/// A divider between groups.
Separator,
/// A selectable entry that invokes `command` when chosen.
Item {
/// Display label.
label: String,
/// Name of the command invoked on selection.
command: String,
},
}
impl MenuRow {
const fn is_item(&self) -> bool {
matches!(self, MenuRow::Item { .. })
}
}
/// The live state of an open context menu (Q#CM1). Frontend-agnostic:
/// the TUI [`MenuView`] overlay and (later) the GPU producer both render
/// from this. `active` is an index into `rows` that always points at an
/// [`MenuRow::Item`]. `anchor` is the absolute cell the menu opens at
/// (the click point) — the TUI render origin; the GPU positions in
/// pixels locally and ignores it.
pub struct MenuState {
/// Rows top-to-bottom (items + separators).
pub rows: Vec<MenuRow>,
/// Highlighted row index (always an `Item`).
pub active: usize,
/// Absolute `(row, col)` cell the popup renders from.
pub anchor: (u32, u32),
/// Popup width in cells (max label + padding, clamped).
pub width: u32,
}
/// Min / max popup width in cells.
const MENU_MIN_WIDTH: u32 = 8;
const MENU_MAX_WIDTH: u32 = 48;
impl MenuState {
/// Build from a resolved row list. Returns `None` when no row is an
/// `Item` (an empty menu never opens). Width is the widest label
/// plus padding, clamped to [`MENU_MIN_WIDTH`]..[`MENU_MAX_WIDTH`].
#[must_use]
pub fn new(rows: Vec<MenuRow>, anchor: (u32, u32)) -> Option<Self> {
let active = rows.iter().position(MenuRow::is_item)?;
let widest = rows
.iter()
.filter_map(|r| match r {
MenuRow::Item { label, .. } => Some(label.chars().count() as u32),
MenuRow::Separator => None,
})
.max()
.unwrap_or(0);
let width = (widest + 2).clamp(MENU_MIN_WIDTH, MENU_MAX_WIDTH);
Some(Self {
rows,
active,
anchor,
width,
})
}
/// Move the highlight one `Item` row forward (`delta >= 0`) or back
/// (`delta < 0`), wrapping and skipping separators. Only the sign of
/// `delta` matters — callers step one item at a time.
pub fn step(&mut self, delta: isize) {
let n = self.rows.len();
if n == 0 {
return;
}
let forward = delta >= 0;
for _ in 0..n {
self.active = if forward {
(self.active + 1) % n
} else {
(self.active + n - 1) % n
};
if self.rows[self.active].is_item() {
return;
}
}
}
/// The active item's command name.
#[must_use]
pub fn active_command(&self) -> Option<&str> {
match self.rows.get(self.active)? {
MenuRow::Item { command, .. } => Some(command),
MenuRow::Separator => None,
}
}
/// Map an absolute cell to the row index it covers, but only when
/// that row is a selectable `Item` (separators and cells outside the
/// popup rectangle return `None`).
#[must_use]
pub fn hit(&self, row: u32, col: u32) -> Option<usize> {
let (arow, acol) = self.anchor;
if row < arow || col < acol {
return None;
}
let ri = (row - arow) as usize;
let ci = col - acol;
if ri >= self.rows.len() || ci >= self.width {
return None;
}
self.rows[ri].is_item().then_some(ri)
}
}
/// Shared handle to the open menu (`None` when closed). Held by
/// [`crate::editor_core::EditorCore`] and read by [`MenuView`], mirroring
/// the search store's `Arc<Mutex>` bridge between core state and the
/// overlay that renders it.
pub type SharedMenu = Arc<Mutex<Option<MenuState>>>;
/// A fresh, closed shared menu.
#[must_use]
pub fn make_shared_menu() -> SharedMenu {
Arc::new(Mutex::new(None))
}
/// Popup background (non-selected rows) — a dim fill so the menu reads
/// as a floating surface over the buffer text it occludes.
fn menu_style() -> Style {
Style {
fg: Color::Indexed(252),
bg: Color::Indexed(236),
..Style::default()
}
}
/// Highlighted-row style (the active item).
fn menu_selected_style() -> Style {
Style {
fg: Color::Indexed(231),
bg: Color::Indexed(24),
..Style::default()
}
}
/// TUI overlay that paints the open menu (Q#CM1). Persistent on the
/// active window once attached (deduped by [`View::kind`]); renders
/// nothing while the menu is closed, mirroring `SearchView`'s
/// self-suppressing model. Owns every cell inside the popup rectangle,
/// occluding the buffer text beneath.
pub struct MenuView {
menu: SharedMenu,
}
impl MenuView {
/// Build a view reading `menu`.
#[must_use]
pub fn new(menu: SharedMenu) -> Self {
Self { menu }
}
}
impl View for MenuView {
fn kind(&self) -> &'static str {
"context-menu"
}
fn render(&mut self, _buf: &Buffer, viewport: Viewport, cells: &mut CellGrid<'_>) {
let guard = self.menu.lock().expect("menu mutex poisoned");
let Some(menu) = guard.as_ref() else {
return;
};
let top = viewport.cell_origin.row;
let left = viewport.cell_origin.col;
let bottom = top + viewport.cell_size.rows;
let right = left + viewport.cell_size.cols;
let (arow, acol) = menu.anchor;
for (i, row) in menu.rows.iter().enumerate() {
let r = arow + i as u32;
if r < top || r >= bottom {
continue; // clip rows that fall outside the window
}
let selected = i == menu.active;
let row_style = if selected {
menu_selected_style()
} else {
menu_style()
};
// Paint the full-width row background first.
for c in 0..menu.width {
let col = acol + c;
if col < left || col >= right {
continue;
}
let cell = cells.at(CellCoord::new(r, col));
cell.glyph = Glyph::Char(' ');
cell.style = row_style;
cell.attachment = None;
}
match row {
MenuRow::Separator => {
for c in 0..menu.width {
let col = acol + c;
if col < left || col >= right {
continue;
}
cells.at(CellCoord::new(r, col)).glyph = Glyph::Char('─');
}
}
MenuRow::Item { label, .. } => {
// One cell of left padding; stop at the popup's right edge.
let row_right = (acol + menu.width).min(right);
for (col, ch) in (acol + 1..).zip(label.chars()) {
if col >= row_right {
break;
}
let cell = cells.at(CellCoord::new(r, col));
cell.glyph = Glyph::Char(ch);
cell.style = row_style;
cell.attachment = None;
}
}
}
}
}
}
// ---------------------------------------------------------------------------
// Tests
// ---------------------------------------------------------------------------
#[cfg(test)]
mod tests {
use super::*;
use mlua::Lua;
fn item(id: Option<&str>, label: &str, command: &str) -> MenuItem {
MenuItem {
id: id.map(ToOwned::to_owned),
label: label.to_owned(),
command: command.to_owned(),
context: None,
predicate: None,
group: String::new(),
order: 0,
source: SourceLocation::default(),
}
}
#[test]
fn add_then_items_round_trips() {
let mut r = MenuRegistry::new();
r.add(item(None, "Copy", "edit.copy")).unwrap();
assert_eq!(r.len(), 1);
assert_eq!(r.items()[0].label, "Copy");
assert_eq!(r.items()[0].command, "edit.copy");
}
#[test]
fn empty_label_is_rejected() {
let mut r = MenuRegistry::new();
assert!(matches!(
r.add(item(None, " ", "edit.copy")),
Err(MenuError::EmptyLabel)
));
}
#[test]
fn empty_command_is_rejected() {
let mut r = MenuRegistry::new();
match r.add(item(None, "Copy", "")) {
Err(MenuError::EmptyCommand { label }) => assert_eq!(label, "Copy"),
other => panic!("expected EmptyCommand, got {other:?}"),
}
}
#[test]
fn unknown_context_is_rejected() {
let mut r = MenuRegistry::new();
let mut it = item(None, "Copy", "edit.copy");
it.context = Some("selecton".into());
match r.add(it) {
Err(MenuError::UnknownContext { label, context }) => {
assert_eq!(label, "Copy");
assert_eq!(context, "selecton");
}
other => panic!("expected UnknownContext, got {other:?}"),
}
}
#[test]
fn known_contexts_are_accepted() {
let mut r = MenuRegistry::new();
for cx in KNOWN_CONTEXTS {
let mut it = item(None, "X", "x.cmd");
it.context = Some((*cx).to_owned());
r.add(it).unwrap();
}
assert_eq!(r.len(), KNOWN_CONTEXTS.len());
}
#[test]
fn predicate_is_stored() {
let lua = Lua::new();
let mut r = MenuRegistry::new();
let mut it = item(None, "Paste", "edit.paste");
it.predicate = Some(lua.create_function(|_, ()| Ok(true)).unwrap());
r.add(it).unwrap();
assert!(r.items()[0].predicate.is_some());
}
#[test]
fn matching_id_replaces_in_place() {
let mut r = MenuRegistry::new();
r.add(item(Some("a"), "First", "cmd.a")).unwrap();
r.add(item(Some("b"), "Second", "cmd.b")).unwrap();
// Override `a` in place: stays at slot 0 with the new label.
r.add(item(Some("a"), "First!", "cmd.a")).unwrap();
assert_eq!(r.len(), 2);
assert_eq!(r.items()[0].label, "First!");
assert_eq!(r.items()[1].label, "Second");
}
#[test]
fn remove_by_id_drops_the_item() {
let mut r = MenuRegistry::new();
r.add(item(Some("a"), "A", "cmd.a")).unwrap();
r.add(item(None, "B", "cmd.b")).unwrap();
assert!(r.remove("a"));
assert!(!r.remove("a")); // already gone
assert_eq!(r.len(), 1);
assert_eq!(r.items()[0].label, "B");
}
#[test]
fn clear_empties_the_registry() {
let mut r = MenuRegistry::new();
r.add(item(None, "A", "cmd.a")).unwrap();
r.add(item(None, "B", "cmd.b")).unwrap();
r.clear();
assert!(r.is_empty());
}
#[test]
fn items_without_id_both_append() {
let mut r = MenuRegistry::new();
r.add(item(None, "A", "cmd.a")).unwrap();
r.add(item(None, "A", "cmd.a")).unwrap();
// No id → no dedup; both are kept.
assert_eq!(r.len(), 2);
}
// ---- MenuState (open-menu runtime) -------------------------------------
fn row_item(label: &str) -> MenuRow {
MenuRow::Item {
label: label.to_owned(),
command: format!("cmd.{label}"),
}
}
#[test]
fn menu_state_new_requires_a_selectable_item() {
assert!(MenuState::new(vec![], (0, 0)).is_none());
assert!(MenuState::new(vec![MenuRow::Separator], (0, 0)).is_none());
// active lands on the first item, skipping a leading separator.
let m = MenuState::new(vec![MenuRow::Separator, row_item("A")], (2, 3)).unwrap();
assert_eq!(m.active, 1);
assert_eq!(m.anchor, (2, 3));
}
#[test]
fn menu_state_step_skips_separators_and_wraps() {
let rows = vec![row_item("A"), MenuRow::Separator, row_item("B")];
let mut m = MenuState::new(rows, (0, 0)).unwrap();
assert_eq!(m.active, 0);
m.step(1);
assert_eq!(m.active, 2); // jumps over the separator at row 1
m.step(1);
assert_eq!(m.active, 0); // wraps to the top
m.step(-1);
assert_eq!(m.active, 2); // wraps back, still skipping the separator
}
#[test]
fn menu_state_hit_maps_cells_to_item_rows_only() {
let rows = vec![row_item("A"), MenuRow::Separator, row_item("B")];
let m = MenuState::new(rows, (5, 10)).unwrap();
// Row 5 = item A (anywhere within the popup width).
assert_eq!(m.hit(5, 10), Some(0));
assert_eq!(m.hit(5, 10 + m.width - 1), Some(0));
// Row 6 = separator → not selectable.
assert_eq!(m.hit(6, 10), None);
// Row 7 = item B.
assert_eq!(m.hit(7, 12), Some(2));
// Outside the popup rectangle in each direction.
assert_eq!(m.hit(4, 10), None); // above
assert_eq!(m.hit(8, 10), None); // below
assert_eq!(m.hit(5, 9), None); // left
assert_eq!(m.hit(5, 10 + m.width), None); // right
}
#[test]
fn menu_state_active_command_reads_the_highlight() {
let mut m = MenuState::new(vec![row_item("A"), row_item("B")], (0, 0)).unwrap();
assert_eq!(m.active_command(), Some("cmd.A"));
m.step(1);
assert_eq!(m.active_command(), Some("cmd.B"));
}
}
Reference in New Issue View Git Blame Copy Permalink