R9.5: merge PR #6, ElyTable completion keys and overlay clicks

Enter and Tab are resolved by the worker against the kernel's current
candidates, after the typing queued before them. The dropdown arrow's
mouse blocker is at least as tall as the button.
This commit is contained in:
雷电芽衣 committed 2026-10-20 03:14:24 -04:00
commit ff317dd863
22 files changed
+696 -48

No files matched your search

+20 -6
View File
@@ -76,12 +76,26 @@ impl Doc {
Unpack::new(&payload).str()
}
/// Completes the function name being typed (TABLE-03).
pub fn complete_function(&self, worker: &mut Worker, name: &str) -> io::Result<()> {
log::info!("lok: completes a function");
let request = Pack::new().u64(worker.doc_id(self)?).str(name).bytes();
worker.request(tag::COMPLETE_FUNCTION, &request)?;
Ok(())
/// Completes `name` if offered; a key takes any, else goes in (TABLE-03).
pub fn complete_function(
&self,
worker: &mut Worker,
name: Option<&str>,
key: Option<(u32, i32)>,
) -> io::Result<bool> {
let pack = Pack::new().u64(worker.doc_id(self)?);
let pack = match name {
Some(name) => pack.u64(1).str(name),
None => pack.u64(0),
};
// Key code 0: no key, as for a click.
let (char_code, key_code) = key.unwrap_or((0, 0));
let request = pack
.i64(i64::from(char_code))
.i64(i64::from(key_code))
.bytes();
let reply = worker.request(tag::COMPLETE_FUNCTION, &request)?;
Ok(Unpack::new(&reply).u64()? == 1)
}
/// Shows sheet `part`, from 0.
+2 -2
View File
@@ -50,8 +50,8 @@ fn typing_a_formula_offers_functions_usage_and_marks() {
sum.is_some_and(|f| f.signature.contains(", ")),
"the signature takes the Excel separator: {sum:?}"
);
doc.complete_function(&mut worker, "SUMIF")
.expect("the completion");
let taken = doc.complete_function(&mut worker, Some("SUMIF"), None);
assert!(taken.expect("the completion"), "SUMIF is on offer");
let done = poll_until(&mut worker, &doc, &offered, SETTLE, |seen| {
seen.cell.formula == "=SUMIF()"
});
+1 -1
View File
@@ -11,7 +11,7 @@ use crate::ffi::Document;
mod cell;
mod parse;
pub use cell::{Cell, Function, Mark, Request};
pub use cell::{Cell, Function, Mark, Request, offered};
use cell::{functions_of, marks_of, request_of, usage_of};
pub use parse::A11y;
use parse::{
+13
View File
@@ -5,6 +5,19 @@ use serde_json::Value;
use super::Rect;
use crate::ipc::{Pack, Unpack};
/// The function names `id` offers now.
pub fn offered(id: u64) -> Vec<String> {
let slots = super::slots().lock().expect("the events lock");
slots.get(&id).map_or_else(Vec::new, |slot| {
slot.batch
.cell
.functions
.iter()
.map(|function| function.name.clone())
.collect()
})
}
/// What a spreadsheet reports about the current cell.
#[derive(Clone, Debug, Default, PartialEq)]
pub struct Cell {
+3
View File
@@ -123,6 +123,7 @@ pub struct LokView {
pointer: gpui::CursorStyle,
selection: Vec<Rect>,
cell: crate::Cell,
completion: formula::Completion,
/// Whether the kernel was told Ely's scheme.
lit: bool,
/// The zoom follows the viewport so a page fits.
@@ -218,6 +219,7 @@ impl LokView {
pointer: gpui::CursorStyle::Arrow,
selection: Vec::new(),
cell: crate::Cell::default(),
completion: formula::Completion::default(),
lit: false,
fit: false,
turning: None,
@@ -392,6 +394,7 @@ impl LokView {
self.picked = 0;
}
self.cell = batch.cell;
self.completion.reported(batch.revision);
self.graphic = batch.graphic;
self.read_borders(batch.table, batch.revision);
self.review = batch.review;
+37 -17
View File
@@ -5,11 +5,17 @@ use ely_gpui_component::{
primitives::raise,
};
use gpui::{
AnyElement, Bounds, Context, Hsla, IntoElement, Keystroke, Modifiers, ParentElement, Pixels,
anchored, rgb,
AnyElement, Bounds, Context, Hsla, InteractiveElement, IntoElement, Keystroke, Modifiers,
ParentElement, Pixels, anchored, div, rgb,
};
use super::{LokView, input::Input};
use super::{
LokView,
input::{Input, vcl_key},
};
mod completion;
pub(super) use completion::Completion;
impl LokView {
/// The sheet shown, which reference marks follow.
@@ -48,7 +54,7 @@ impl LokView {
/// Up and Down walk the offered functions.
pub(super) fn walk(&mut self, keystroke: &Keystroke, cx: &mut Context<Self>) -> bool {
let count = self.cell.functions.len();
if count == 0 || keystroke.modifiers != Modifiers::none() {
if count == 0 || self.completion.pending() || keystroke.modifiers != Modifiers::none() {
return false;
}
self.picked = match keystroke.key.as_str() {
@@ -60,32 +66,46 @@ impl LokView {
true
}
/// Takes the chosen function, in order with typing.
pub(super) fn complete(&mut self) -> bool {
let Some(item) = self.offered().into_iter().nth(self.picked) else {
return false;
};
log::info!("lok: completes {}", item.label);
self.send(Input::Complete(item.label.to_string()));
true
/// Enter or Tab: the kernel's function then, else the key.
pub(super) fn complete_or_press(&mut self, keystroke: &Keystroke) {
let key = vcl_key(keystroke).expect("Enter and Tab are vcl keys");
let name = (!self.completion.pending())
.then(|| self.offered().into_iter().nth(self.picked))
.flatten()
.map(|item| item.label.to_string());
self.take(name, Some(key));
}
/// A clicked function, if the kernel still offers it then.
fn complete_function(&mut self, name: &str) {
if !self.completion.pending() {
self.take(Some(name.to_string()), None);
}
}
/// Queues the choice in order with typing; the worker decides.
fn take(&mut self, name: Option<String>, key: Option<(u32, i32)>) {
self.send(Input::Complete { name, key });
self.completion.queued(self.sent);
self.picked = 0;
}
/// The offered functions, else the call's usage, under the cell.
pub(super) fn hints(&self, cx: &mut Context<Self>) -> Option<AnyElement> {
if self.completion.pending() {
return None;
}
let cell = self.screen_rect(self.cell.cursor?);
let hint = if self.cell.functions.is_empty() {
SignatureHelp::new("lok-view-usage", [usage(&self.cell.usage)?]).into_any_element()
} else {
let this = cx.entity();
let offered = self.offered();
let labels: Vec<_> = offered.iter().map(|item| item.label.clone()).collect();
CompletionMenu::new("lok-view-functions", offered)
.selected(self.picked)
.on_pick(move |item, _, cx| {
let at = labels.iter().position(|label| *label == item.label);
this.update(cx, |view, cx| {
view.picked = at.expect("a picked item is offered");
view.complete();
view.complete_function(&item.label);
cx.notify();
})
})
@@ -94,7 +114,7 @@ impl LokView {
let place = anchored()
.position(cell.bottom_left())
.snap_to_window()
.child(hint);
.child(div().block_mouse_except_scroll().child(hint));
Some(raise("lok-view-hints", place).into_any_element())
}
}
@@ -0,0 +1,116 @@
#[derive(Default)]
pub(crate) struct Completion {
pending: Option<(u64, Option<u64>)>,
reported: u64,
}
impl Completion {
pub(crate) fn pending(&self) -> bool {
self.pending.is_some()
}
pub(crate) fn queued(&mut self, seq: u64) {
self.pending = Some((seq, None));
}
pub(crate) fn reported(&mut self, revision: u64) {
self.reported = revision;
self.finish();
}
pub(crate) fn landed(&mut self, seq: u64, revision: Option<u64>) {
if self.pending.is_some_and(|(waiting, _)| waiting == seq) {
self.pending = revision.map(|revision| (seq, Some(revision)));
self.finish();
}
}
fn finish(&mut self) {
// Inline callbacks and serialized output preserve completion revisions.
if self
.pending
.is_some_and(|(_, revision)| revision.is_some_and(|revision| self.reported >= revision))
{
self.pending = None;
}
}
}
#[cfg(test)]
mod tests {
use super::Completion;
#[test]
fn an_old_snapshot_cannot_reopen_an_accepted_menu() {
let mut completion = Completion::default();
completion.reported(10);
completion.queued(7);
completion.reported(10);
assert!(completion.pending());
completion.landed(7, Some(11));
assert!(completion.pending());
completion.reported(10);
assert!(completion.pending());
completion.reported(11);
assert!(!completion.pending());
}
#[test]
fn a_snapshot_before_the_reply_waits_for_the_reply() {
let mut completion = Completion::default();
completion.queued(7);
completion.reported(11);
assert!(completion.pending());
completion.landed(7, Some(11));
assert!(!completion.pending());
}
#[test]
fn a_reply_before_the_snapshot_waits_for_the_snapshot() {
let mut completion = Completion::default();
completion.queued(7);
completion.landed(7, Some(11));
assert!(completion.pending());
completion.reported(11);
assert!(!completion.pending());
}
#[test]
fn another_input_cannot_acknowledge_the_completion() {
let mut completion = Completion::default();
completion.queued(7);
completion.reported(20);
completion.landed(6, Some(20));
assert!(completion.pending());
completion.landed(8, None);
assert!(completion.pending());
completion.landed(7, Some(19));
assert!(!completion.pending());
}
#[test]
fn a_failed_completion_allows_retry() {
let mut completion = Completion::default();
completion.queued(7);
completion.landed(7, None);
assert!(!completion.pending());
completion.queued(8);
assert!(completion.pending());
}
#[test]
fn the_next_completion_requires_its_own_snapshot() {
let mut completion = Completion::default();
completion.reported(11);
completion.queued(7);
completion.landed(7, Some(11));
assert!(!completion.pending());
completion.queued(8);
completion.landed(8, Some(12));
assert!(completion.pending());
completion.reported(11);
assert!(completion.pending());
completion.reported(12);
assert!(!completion.pending());
}
}
+28 -8
View File
@@ -45,8 +45,11 @@ pub(super) enum Input {
Paste,
/// Values or formulas alone: `paste.values` or `paste.formulas`.
PasteOnly(&'static str),
/// A function the kernel offered, taken.
Complete(String),
/// A function the kernel offers then, else Enter or Tab.
Complete {
name: Option<String>,
key: Option<(u32, i32)>,
},
/// The kernel's color scheme; not an edit.
Theme(&'static str),
/// Commands in order, from one read.
@@ -72,6 +75,8 @@ pub(super) enum Input {
pub(super) enum Back {
Copied(String),
Shown(usize),
/// Whether a function was taken.
Completed(bool),
}
impl Input {
@@ -92,7 +97,7 @@ impl Input {
| Input::Paste
| Input::PasteOnly(_)
| Input::Drag { .. }
| Input::Complete(_) => true,
| Input::Complete { .. } => true,
}
}
}
@@ -201,7 +206,10 @@ fn apply(worker: &mut Worker, doc: &Doc, input: Input) -> io::Result<Option<Back
Input::Drag { from, to } => worker.drag_graphic(doc, from, to),
Input::Visible(area, scale) => doc.visible_area(worker, area, scale),
Input::Part(part) => doc.show_sheet(worker, part),
Input::Complete(name) => doc.complete_function(worker, &name),
Input::Complete { name, key } => {
let taken = doc.complete_function(worker, name.as_deref(), key)?;
return Ok(Some(Back::Completed(taken)));
}
Input::Theme(scheme) => worker.run(doc, "view.theme", &[scheme]),
Input::Text { commit, text } => worker.post_text(doc, commit, &text),
Input::Copy { cut } => {
@@ -270,6 +278,10 @@ impl LokView {
/// Posts a non-text key; text waits for the IME.
pub(super) fn key_down(&mut self, keystroke: &Keystroke) -> bool {
if keystroke.key == "enter" && keystroke.modifiers == Modifiers::none() {
self.complete_or_press(keystroke);
return true;
}
let Some((char_code, key_code)) = vcl_key(keystroke) else {
return false;
};
@@ -307,10 +319,14 @@ impl LokView {
_: &mut Window,
cx: &mut Context<Self>,
) {
let completing = self.completion.pending();
if self.walk(&event.keystroke, cx)
|| self.turn_key(&event.keystroke)
|| self.key_down(&event.keystroke)
{
if !completing && self.completion.pending() {
cx.notify();
}
cx.stop_propagation();
}
}
@@ -425,10 +441,14 @@ impl LokView {
self.send(Input::Paste);
}
pub(super) fn on_next_field(&mut self, _: &NextField, _: &mut Window, _: &mut Context<Self>) {
if !self.complete() {
self.key_down(&Keystroke::parse("tab").expect("a keystroke"));
}
pub(super) fn on_next_field(&mut self, _: &NextField, _: &mut Window, cx: &mut Context<Self>) {
self.next_field();
cx.notify();
}
/// Tab takes the offered function, else moves on.
pub(super) fn next_field(&mut self) {
self.complete_or_press(&Keystroke::parse("tab").expect("a keystroke"));
}
pub(super) fn on_previous_field(
+4 -1
View File
@@ -107,6 +107,9 @@ impl LokView {
}
self.edited += u64::from(edits);
let (outcome, now) = outcome;
// A plain key took nothing; the menu may return.
let taken = matches!(outcome, Ok(Some(Back::Completed(true))));
self.completion.landed(seq, if taken { now } else { None });
if edits {
self.clock.landed(now);
}
@@ -118,7 +121,7 @@ impl LokView {
self.part = part;
self.invalidate(cx);
}
Ok(Some(Back::Shown(_))) => {}
Ok(Some(Back::Shown(_) | Back::Completed(_))) => {}
Ok(None) => {}
Err(error) => {
log::error!("lok: input failed ({:?})", error.kind());
+1
View File
@@ -4,6 +4,7 @@ mod borders;
mod clip;
mod commands;
mod fit;
mod formula;
mod input;
mod large;
mod show_borders;
+272
View File
@@ -0,0 +1,272 @@
use super::*;
use gpui::{Keystroke, TestAppContext};
fn settle(cx: &TestAppContext, done: impl Fn(&App) -> bool) -> bool {
let deadline = std::time::Instant::now() + std::time::Duration::from_secs(10);
while std::time::Instant::now() < deadline {
if !cx.executor().tick() {
cx.executor()
.advance_clock(std::time::Duration::from_millis(20));
}
if cx.update(|app| done(app)) {
return true;
}
}
false
}
#[test]
fn enter_completes_the_selected_function_without_leaving_the_cell() {
let Some(install) = crate::client::tests::install() else {
eprintln!("SKIP: no pinned LOK build");
return;
};
let mut cx = TestAppContext::single();
cx.update(ely_gpui_component::init_for_tests);
let (view, _) = cx.update(|app| {
live_view_of(
app,
&install,
"book.fods",
crate::client::tests::input::FODS,
)
});
let (_, window) = cx.add_window_view(|_, _| Host(view.clone()));
window.run_until_parked();
window.update(|window, app| {
let focus = view.read(app).focus_handle().clone();
focus.focus(window, app);
});
assert!(settle(window, |app| !view
.read(app)
.cell
.address
.is_empty()));
let address = window.update(|_, app| view.read(app).cell.address.clone());
view.update(window, |view, _| view.commit(None, "=lo"));
assert!(settle(window, |app| {
let functions = &view.read(app).cell.functions;
functions.iter().any(|item| item.name == "LOOKUP")
&& functions.iter().any(|item| item.name == "LOG")
}));
// Keep two valid offers to exercise keyboard selection.
view.update(window, |view, cx| {
view.cell
.functions
.retain(|item| item.name == "LOG" || item.name == "LOOKUP");
cx.notify();
});
window.simulate_keystrokes("down enter");
assert!(
settle(window, |app| {
let view = view.read(app);
view.settled() && view.cell.formula == "=LOOKUP()" && view.cell.functions.is_empty()
}),
"Enter inserts the selected function"
);
window.update(|_, app| {
assert_eq!(
view.read(app).cell.address,
address,
"completion stays in the cell"
);
view.update(app, |view, _| {
view.commit(None, "1,1,1");
});
});
assert!(settle(window, |app| {
let view = view.read(app);
view.settled() && view.cell.formula == "=LOOKUP(1,1,1)"
}));
window.simulate_keystrokes("enter");
assert!(
settle(window, |app| {
let view = view.read(app);
view.settled() && view.cell.address != address
}),
"Enter without candidates commits and moves to the next cell"
);
}
#[test]
fn accepting_a_candidate_consumes_it_before_the_worker_answers() {
let Some(install) = crate::client::tests::install() else {
eprintln!("SKIP: no pinned LOK build");
return;
};
let cx = TestAppContext::single();
let (view, worker) = cx.update(|app| {
live_view_of(
app,
&install,
"book.fods",
crate::client::tests::input::FODS,
)
});
cx.update(|app| view.update(app, |view, _| view.commit(None, "=look")));
assert!(settle(&cx, |app| view
.read(app)
.cell
.functions
.iter()
.any(|item| item.name == "LOOKUP")));
let held = worker.lock().expect("the worker lock");
cx.update(|app| {
view.update(app, |view, cx| {
let old = Events {
revision: view.doc.rev,
cell: view.cell.clone(),
..Events::default()
};
let before = view.sent();
assert!(view.key_down(&Keystroke::parse("enter").expect("Enter")));
view.apply_batch(old, None, cx);
assert!(
view.completion.pending(),
"an old event must not reoffer an accepted candidate"
);
assert_eq!(view.sent(), before + 1);
assert!(view.key_down(&Keystroke::parse("enter").expect("Enter")));
assert_eq!(
view.sent(),
before + 2,
"the second Enter is queued normally"
);
})
});
drop(held);
assert!(
settle(&cx, |app| {
let view = view.read(app);
view.settled() && view.cell.address == "A2"
}),
"the second Enter commits and moves down"
);
}
#[test]
fn enter_or_tab_after_queued_typing_follows_the_kernel_not_the_menu() {
let Some(install) = crate::client::tests::install() else {
eprintln!("SKIP: no pinned LOK build");
return;
};
for (key, to) in [("enter", "A2"), ("tab", "B1")] {
let cx = TestAppContext::single();
let (view, worker) = cx.update(|app| {
live_view_of(
app,
&install,
"book.fods",
crate::client::tests::input::FODS,
)
});
cx.update(|app| view.update(app, |view, _| view.commit(None, "=sum")));
assert!(settle(&cx, |app| view
.read(app)
.cell
.functions
.iter()
.any(|item| item.name == "SUM")));
// The worker waits; the menu still shows SUM.
let held = worker.lock().expect("the worker lock");
cx.update(|app| {
view.update(app, |view, _| {
for text in ["(", "1", ")"] {
view.commit(None, text);
}
match key {
"enter" => assert!(view.key_down(&Keystroke::parse(key).expect("a key"))),
_ => view.next_field(),
}
})
});
drop(held);
assert!(
settle(&cx, |app| {
let view = view.read(app);
view.settled() && view.cell.address == to
}),
"{key} commits =sum(1) and moves to {to}"
);
}
}
struct Host(Entity<LokView>);
impl gpui::Render for Host {
fn render(
&mut self,
_: &mut gpui::Window,
_: &mut gpui::Context<Self>,
) -> impl gpui::IntoElement {
self.0.clone()
}
}
#[test]
fn clicking_a_function_does_not_send_mouse_input_to_the_sheet() {
let Some(install) = crate::client::tests::install() else {
eprintln!("SKIP: no pinned LOK build");
return;
};
let mut cx = TestAppContext::single();
cx.update(ely_gpui_component::init_for_tests);
let (view, _) = cx.update(|app| {
live_view_of(
app,
&install,
"book.fods",
crate::client::tests::input::FODS,
)
});
let (_, window) = cx.add_window_view(|_, _| Host(view.clone()));
window.run_until_parked();
view.update(window, |view, _| view.commit(None, "=look"));
assert!(settle(window, |app| {
let view = view.read(app);
view.settled() && view.cell.functions.len() == 1 && view.cell.functions[0].name == "LOOKUP"
}));
window.run_until_parked();
let (on, address, sent) = window.update(|_, app| {
let view = view.read(app);
let cell = view.screen_rect(view.cell.cursor.expect("the cell cursor"));
(
cell.bottom_left() + point(px(12.0), px(12.0)),
view.cell.address.clone(),
view.sent(),
)
});
window.simulate_mouse_down(on, gpui::MouseButton::Left, Default::default());
window.update(|_, app| {
let view = view.read(app);
assert_eq!(view.sent(), sent, "the sheet never receives the press");
assert!(
!view.dragging,
"the candidate press never starts a sheet drag"
);
});
// Change candidates without repainting the already pressed row.
view.update(window, |view, _| {
view.cell.functions.insert(
0,
crate::Function {
name: "LOG".into(),
signature: String::new(),
description: String::new(),
},
);
});
window.simulate_mouse_up(on, gpui::MouseButton::Left, Default::default());
assert!(
settle(window, |app| {
let view = view.read(app);
view.settled() && view.cell.formula == "=LOOKUP()"
}),
"the candidate receives the click"
);
window.update(|_, app| {
let view = view.read(app);
assert_eq!(view.cell.address, address, "the active cell stays put");
assert_eq!(view.sent(), sent + 1, "only completion reaches the sheet");
});
}
+2 -7
View File
@@ -7,6 +7,7 @@ use std::{
use crate::ffi::{Document, Lok};
use crate::ipc::{self, Pack, Unpack, tag};
mod complete;
mod events;
#[cfg(unix)]
mod fatal;
@@ -264,13 +265,7 @@ fn answer(lok: &Lok, tag: u8, id: u64, payload: &[u8]) {
.and_then(|id| with_doc(id, |doc| doc.selection_text()))
.and_then(|text| text)
.map(|text| Pack::new().str(&text).bytes()),
tag::COMPLETE_FUNCTION => unpack
.u64()
.and_then(|id| {
let name = unpack.str()?;
with_doc(id, |doc| doc.complete_function(&name)).and_then(|done| done)
})
.map(|()| Vec::new()),
tag::COMPLETE_FUNCTION => complete::complete(unpack),
tag::SET_AUTHOR => unpack
.str()
.and_then(|name| lok.set_option("author", &name))
+43
View File
@@ -0,0 +1,43 @@
//! A function the kernel offers, taken in input order (TABLE-03).
use std::io;
use super::with_doc;
use crate::ipc::{Pack, Unpack};
/// Takes an offered function, else posts Enter or Tab; 1 if taken.
pub(super) fn complete(unpack: &mut Unpack) -> io::Result<Vec<u8>> {
let id = unpack.u64()?;
let name = match unpack.u64()? {
0 => None,
_ => Some(unpack.str()?),
};
let (char_code, key_code) = (unpack.i64()?, unpack.i64()?);
// No key: a click; else Enter (1280) or Tab (1282).
if !matches!(key_code, 0 | 1280 | 1282) {
return Err(io::Error::new(
io::ErrorKind::InvalidInput,
"a completion takes Enter or Tab",
));
}
// Earlier input's callbacks already landed here.
let offered = crate::events::offered(id);
let take = match name {
Some(name) if offered.contains(&name) => Some(name),
// As the menu orders them: shortest first.
_ if key_code != 0 => offered.into_iter().min_by_key(String::len),
_ => None,
};
if let Some(name) = take {
log::info!("lok-worker: completes a function");
with_doc(id, |doc| doc.complete_function(&name))??;
return Ok(Pack::new().u64(1).bytes());
}
if key_code != 0 {
with_doc(id, |doc| {
doc.post_key(0, char_code as i32, key_code as i32);
doc.post_key(1, char_code as i32, key_code as i32);
})?;
}
Ok(Pack::new().u64(0).bytes())
}