mod lexical_typeahead_menu_plugin_utils;
pub use lexical_typeahead_menu_plugin_utils::{
PUNCTUATION, SCROLL_TYPEAHEAD_OPTION_INTO_VIEW_COMMAND, ScrollTypeaheadOptionIntoViewPayload,
TypeaheadTriggerOptions, basic_typeahead_trigger_match,
};
use crate::commands::{
KEY_ARROW_DOWN_COMMAND, KEY_ARROW_UP_COMMAND, KEY_ENTER_COMMAND, KEY_ESCAPE_COMMAND,
KEY_TAB_COMMAND,
};
use crate::editor::COMMAND_PRIORITY_LOW;
use crate::events::KeyboardEvent;
use crate::lexical_selection::{PointType, RangeSelection, get_selection};
use crate::merge_register::merge_register;
use crate::{Editor, LexicalError, NodeKey, NodeRef, Unregister, UpdateOptions, utf16};
use std::cell::RefCell;
use std::rc::Rc;
#[derive(Clone, Debug, PartialEq, Eq)]
pub struct MenuTextMatch {
pub lead_offset: usize,
pub matching_string: String,
pub replaceable_string: String,
}
pub type TriggerFn = Rc<dyn Fn(&str, &Editor) -> Option<MenuTextMatch>>;
pub trait MenuOption {
fn key(&self) -> &str;
fn title(&self) -> Option<&str> {
None
}
}
#[derive(Clone, Debug, PartialEq, Eq)]
pub struct MenuResolution {
pub text_match: Option<MenuTextMatch>,
pub anchor_key: NodeKey,
pub start_offset: usize,
pub end_offset: usize,
}
pub fn get_full_match_offset(document_text: &str, entry_text: &str, offset: usize) -> usize {
let document: Vec<u16> = document_text.encode_utf16().collect();
let entry: Vec<u16> = entry_text.encode_utf16().collect();
let mut trigger_offset = offset;
for i in offset..=entry.len() {
let suffix = if i == 0 {
&document[..]
} else {
&document[document.len().saturating_sub(i)..]
};
if suffix == &entry[..i] {
trigger_offset = i;
}
}
trigger_offset
}
fn anchor_text(selection: &RangeSelection) -> Option<(NodeRef, String)> {
let anchor = &selection.anchor;
if anchor.point_type != PointType::Text {
return None;
}
let anchor_node = anchor.get_node().ok()?;
if !anchor_node.is_simple_text() {
return None;
}
let text = utf16::slice(&anchor_node.get_text_content(), 0, anchor.offset);
Some((anchor_node, text))
}
pub fn split_node_containing_query(
text_match: &MenuTextMatch,
) -> Result<Option<NodeRef>, LexicalError> {
let Some(selection) = get_selection().and_then(|s| s.range()) else {
return Ok(None);
};
if !selection.is_collapsed() {
return Ok(None);
}
let Some((anchor_node, text_content)) = anchor_text(&selection) else {
return Ok(None);
};
let selection_offset = selection.anchor.offset;
let character_offset = utf16::len(&text_match.replaceable_string);
let query_offset =
get_full_match_offset(&text_content, &text_match.matching_string, character_offset);
let Some(start_offset) = selection_offset.checked_sub(query_offset) else {
return Ok(None);
};
let parts = if start_offset == 0 {
anchor_node.split_text(&[selection_offset as i64])?
} else {
let mut parts = anchor_node.split_text(&[start_offset as i64, selection_offset as i64])?;
if parts.is_empty() {
parts
} else {
parts.split_off(1)
}
};
Ok(parts.into_iter().next())
}
pub fn get_text_up_to_anchor(selection: &RangeSelection) -> Option<String> {
anchor_text(selection).map(|(_, text)| text)
}
pub fn is_selection_on_entity_boundary(editor: &Editor, offset: usize) -> bool {
if offset != 0 {
return false;
}
editor.get_editor_state().read(|| {
get_selection()
.and_then(|s| s.range())
.and_then(|range| range.anchor.get_node().ok())
.and_then(|node| node.get_previous_sibling())
.is_some_and(|prev| prev.is_text() && prev.is_text_entity())
})
}
pub type MenuSelectOption<O> =
Rc<dyn Fn(&Rc<O>, Option<NodeRef>, &dyn Fn(), &str) -> Result<(), LexicalError>>;
struct MenuInner<O> {
resolution: Option<MenuResolution>,
options: Vec<Rc<O>>,
selected_index: Option<isize>,
is_open: bool,
draws_empty_menu: bool,
unregister_commands: Option<Unregister>,
open_generation: u64,
}
pub struct MenuState<O> {
editor: Editor,
inner: Rc<RefCell<MenuInner<O>>>,
command_priority: i8,
preselect_first_item: bool,
should_split_node_with_query: bool,
on_select_option: MenuSelectOption<O>,
callbacks: Rc<MenuCallbacks>,
}
impl<O> Clone for MenuState<O> {
fn clone(&self) -> Self {
self.with_editor(&self.editor)
}
}
impl<O> MenuState<O> {
fn with_editor(&self, editor: &Editor) -> Self {
MenuState {
editor: editor.clone(),
inner: self.inner.clone(),
command_priority: self.command_priority,
preselect_first_item: self.preselect_first_item,
should_split_node_with_query: self.should_split_node_with_query,
on_select_option: self.on_select_option.clone(),
callbacks: self.callbacks.clone(),
}
}
fn detach(&self) -> DetachedMenu<O> {
DetachedMenu {
inner: self.inner.clone(),
command_priority: self.command_priority,
preselect_first_item: self.preselect_first_item,
should_split_node_with_query: self.should_split_node_with_query,
on_select_option: self.on_select_option.clone(),
callbacks: self.callbacks.clone(),
}
}
}
struct DetachedMenu<O> {
inner: Rc<RefCell<MenuInner<O>>>,
command_priority: i8,
preselect_first_item: bool,
should_split_node_with_query: bool,
on_select_option: MenuSelectOption<O>,
callbacks: Rc<MenuCallbacks>,
}
impl<O> DetachedMenu<O> {
fn menu(&self, editor: &Editor) -> MenuState<O> {
MenuState {
editor: editor.clone(),
inner: self.inner.clone(),
command_priority: self.command_priority,
preselect_first_item: self.preselect_first_item,
should_split_node_with_query: self.should_split_node_with_query,
on_select_option: self.on_select_option.clone(),
callbacks: self.callbacks.clone(),
}
}
}
pub type OnOpen = Rc<dyn Fn(&MenuResolution)>;
pub type OnCloseAsync = Rc<dyn Fn(MenuCloseDone)>;
pub type OnQueryChange = Rc<dyn Fn(Option<&str>)>;
pub struct MenuCloseDone(Option<Box<dyn FnOnce()>>);
impl MenuCloseDone {
pub fn finish(mut self) {
if let Some(finish) = self.0.take() {
finish();
}
}
}
impl Drop for MenuCloseDone {
fn drop(&mut self) {
if let Some(finish) = self.0.take() {
finish();
}
}
}
#[derive(Default)]
pub struct MenuCallbacks {
pub on_open: RefCell<Option<OnOpen>>,
pub on_close: RefCell<Option<Rc<dyn Fn()>>>,
pub on_close_async: RefCell<Option<OnCloseAsync>>,
pub on_change: RefCell<Option<Rc<dyn Fn()>>>,
}
impl<O: MenuOption + 'static> MenuState<O> {
fn new(
editor: &Editor,
command_priority: i8,
preselect_first_item: bool,
should_split_node_with_query: bool,
on_select_option: MenuSelectOption<O>,
) -> Self {
MenuState {
editor: editor.clone(),
inner: Rc::new(RefCell::new(MenuInner {
resolution: None,
options: Vec::new(),
selected_index: None,
is_open: false,
draws_empty_menu: false,
unregister_commands: None,
open_generation: 0,
})),
command_priority,
preselect_first_item,
should_split_node_with_query,
on_select_option,
callbacks: Rc::new(MenuCallbacks::default()),
}
}
pub fn callbacks(&self) -> &MenuCallbacks {
&self.callbacks
}
fn changed(&self) {
let on_change = self.callbacks.on_change.borrow().clone();
if let Some(on_change) = on_change {
on_change();
}
}
pub fn resolution(&self) -> Option<MenuResolution> {
self.inner.borrow().resolution.clone()
}
pub fn options(&self) -> Vec<Rc<O>> {
self.inner.borrow().options.clone()
}
pub fn selected_index(&self) -> Option<usize> {
self.clamped_index()
.and_then(|index| usize::try_from(index).ok())
}
fn clamped_index(&self) -> Option<isize> {
let inner = self.inner.borrow();
let last = inner.options.len() as isize - 1;
inner.selected_index.map(|index| index.min(last))
}
fn selected_option(&self) -> Option<Rc<O>> {
let index = self.selected_index()?;
self.inner.borrow().options.get(index).cloned()
}
pub fn command_priority(&self) -> i8 {
self.command_priority
}
pub fn set_draws_empty_menu(&self, draws_empty_menu: bool) {
self.inner.borrow_mut().draws_empty_menu = draws_empty_menu;
}
fn renders_nothing(&self) -> bool {
let inner = self.inner.borrow();
!inner.draws_empty_menu && inner.options.is_empty()
}
pub fn set_options(&self, options: Vec<Rc<O>>) {
{
let mut inner = self.inner.borrow_mut();
inner.options = options;
if inner.selected_index.is_none()
&& self.preselect_first_item
&& inner.resolution.is_some()
{
inner.selected_index = Some(0);
}
}
self.changed();
}
pub fn set_highlighted_index(&self, index: Option<usize>) {
self.inner.borrow_mut().selected_index = index.map(|i| i as isize);
self.changed();
}
fn open(&self, resolution: MenuResolution) {
let was_open = {
let mut inner = self.inner.borrow_mut();
let query = |r: &Option<MenuResolution>| {
r.as_ref()
.and_then(|r| r.text_match.as_ref())
.map(|m| m.matching_string.clone())
};
if self.preselect_first_item
&& query(&inner.resolution)
!= resolution
.text_match
.as_ref()
.map(|m| m.matching_string.clone())
{
inner.selected_index = Some(0);
}
inner.resolution = Some(resolution.clone());
inner.open_generation += 1;
std::mem::replace(&mut inner.is_open, true)
};
if !was_open {
if self.inner.borrow().unregister_commands.is_none() {
self.register_commands();
}
let on_open = self.callbacks.on_open.borrow().clone();
if let Some(on_open) = on_open {
on_open(&resolution);
}
}
self.changed();
}
pub fn close(&self) {
if !std::mem::replace(&mut self.inner.borrow_mut().is_open, false) {
return;
}
let open_generation = self.inner.borrow().open_generation;
let on_close = self.callbacks.on_close.borrow().clone();
if let Some(on_close) = on_close {
on_close();
}
let on_close_async = self.callbacks.on_close_async.borrow().clone();
match on_close_async {
Some(on_close_async) => {
let menu = self.clone();
on_close_async(MenuCloseDone(Some(Box::new(move || {
menu.finish_close(open_generation)
}))));
}
None => self.finish_close(open_generation),
}
}
fn finish_close(&self, open_generation: u64) {
let unregister_commands = {
let mut inner = self.inner.borrow_mut();
if inner.open_generation != open_generation {
return;
}
inner.resolution = None;
inner.selected_index = None;
inner.unregister_commands.take()
};
if let Some(unregister) = unregister_commands {
unregister();
}
self.changed();
}
fn move_highlight(&self, forward: bool, event: &KeyboardEvent) -> Result<bool, LexicalError> {
if self.renders_nothing() {
return Ok(false);
}
let last = self.inner.borrow().options.len() as isize - 1;
let new_index = match self.clamped_index() {
None if forward => 0,
None => last,
Some(index) if forward => {
if index != last {
index + 1
} else {
0
}
}
Some(index) => {
if index != 0 {
index - 1
} else {
last
}
}
};
self.inner.borrow_mut().selected_index = Some(new_index);
let option = usize::try_from(new_index)
.ok()
.and_then(|index| self.inner.borrow().options.get(index).cloned());
let Some(option) = option else {
self.inner.borrow_mut().selected_index = Some(-1);
self.changed();
event.prevent_default();
return Ok(true);
};
self.editor.dispatch_command(
&SCROLL_TYPEAHEAD_OPTION_INTO_VIEW_COMMAND,
ScrollTypeaheadOptionIntoViewPayload {
index: new_index as usize,
option,
},
)?;
self.changed();
event.prevent_default();
Ok(true)
}
fn register_commands(&self) {
let priority = self.command_priority;
let (down, up, escape, tab, enter) = (
self.detach(),
self.detach(),
self.detach(),
self.detach(),
self.detach(),
);
let unregister = merge_register(vec![
self.editor.register_command(
&KEY_ARROW_DOWN_COMMAND,
move |event, editor| down.menu(editor).move_highlight(true, event),
priority,
),
self.editor.register_command(
&KEY_ARROW_UP_COMMAND,
move |event, editor| up.menu(editor).move_highlight(false, event),
priority,
),
self.editor.register_command(
&KEY_ESCAPE_COMMAND,
move |event, editor| {
let menu = escape.menu(editor);
if menu.renders_nothing() {
return Ok(false);
}
event.prevent_default();
menu.close();
Ok(true)
},
priority,
),
self.editor.register_command(
&KEY_TAB_COMMAND,
move |event, editor| {
let menu = tab.menu(editor);
let Some(option) = menu.selected_option() else {
return Ok(false);
};
event.prevent_default();
menu.select_option_and_clean_up(&option)?;
Ok(true)
},
priority,
),
self.editor.register_command(
&KEY_ENTER_COMMAND,
move |event, editor| {
let menu = enter.menu(editor);
let Some(option) = menu.selected_option() else {
return Ok(false);
};
if event.as_ref().is_some_and(|event| event.shift_key) {
return Ok(false);
}
if let Some(event) = event {
event.prevent_default();
}
menu.select_option_and_clean_up(&option)?;
Ok(true)
},
priority,
),
]);
self.inner.borrow_mut().unregister_commands = Some(unregister);
}
pub fn select_option_and_clean_up(&self, option: &Rc<O>) -> Result<(), LexicalError> {
let text_match = self.resolution().and_then(|r| r.text_match);
let (menu, option) = (self.clone(), option.clone());
self.editor.update(
move || {
let text_node_containing_query = match &text_match {
Some(text_match) if menu.should_split_node_with_query => {
split_node_containing_query(text_match)?
}
_ => None,
};
let close_menu = || menu.close();
(menu.on_select_option)(
&option,
text_node_containing_query,
&close_menu,
text_match
.as_ref()
.map_or("", |m| m.matching_string.as_str()),
)
},
UpdateOptions::default(),
)
}
}
#[derive(Clone, Copy, Debug)]
pub struct TypeaheadMenuOptions {
pub command_priority: i8,
pub preselect_first_item: bool,
pub ignore_entity_boundary: bool,
}
impl Default for TypeaheadMenuOptions {
fn default() -> Self {
TypeaheadMenuOptions {
command_priority: COMMAND_PRIORITY_LOW,
preselect_first_item: true,
ignore_entity_boundary: false,
}
}
}
pub fn register_typeahead_menu<O: MenuOption + 'static>(
editor: &Editor,
trigger_fn: TriggerFn,
on_query_change: OnQueryChange,
on_select_option: MenuSelectOption<O>,
options: TypeaheadMenuOptions,
) -> (MenuState<O>, Unregister) {
let menu = MenuState::new(
editor,
options.command_priority,
options.preselect_first_item,
true,
on_select_option,
);
let listening = menu.clone();
let weak = editor.weak();
let unregister_update = editor.register_update_listener(move |_| {
let Some(editor) = weak.upgrade().map(Editor) else {
return;
};
let menu = &listening;
enum Next {
Close,
CloseUnlessComposing,
Open(MenuResolution),
}
let next = editor.get_editor_state().read(|| {
if !editor.is_editable() {
return Next::Close;
}
let Some(selection) = get_selection().and_then(|s| s.range()) else {
return Next::CloseUnlessComposing;
};
let Some(text) = get_text_up_to_anchor(&selection) else {
return Next::CloseUnlessComposing;
};
if !selection.is_collapsed() {
return Next::CloseUnlessComposing;
}
let text_match = trigger_fn(&text, &editor);
on_query_change(text_match.as_ref().map(|m| m.matching_string.as_str()));
match text_match {
Some(text_match)
if options.ignore_entity_boundary
|| !is_selection_on_entity_boundary(&editor, text_match.lead_offset) =>
{
Next::Open(MenuResolution {
start_offset: text_match.lead_offset,
end_offset: selection.anchor.offset,
anchor_key: selection.anchor.key.clone(),
text_match: Some(text_match),
})
}
_ => Next::CloseUnlessComposing,
}
});
match next {
Next::Close => menu.close(),
Next::CloseUnlessComposing => {
if !editor.is_composing() {
menu.close();
}
}
Next::Open(resolution) => menu.open(resolution),
}
});
let closing = menu.clone();
let unregister_editable = editor.register_editable_listener(move |is_editable| {
if !is_editable {
closing.close();
}
});
let unregister = merge_register(vec![unregister_update, unregister_editable]);
(menu, unregister)
}
pub struct NodeMenu<O> {
menu: MenuState<O>,
node_key: Rc<RefCell<Option<NodeKey>>>,
}
impl<O> Clone for NodeMenu<O> {
fn clone(&self) -> Self {
NodeMenu {
menu: self.menu.clone(),
node_key: self.node_key.clone(),
}
}
}
impl<O: MenuOption + 'static> NodeMenu<O> {
pub fn new(
editor: &Editor,
on_select_option: MenuSelectOption<O>,
command_priority: i8,
) -> Self {
NodeMenu {
menu: MenuState::new(editor, command_priority, true, false, on_select_option),
node_key: Rc::new(RefCell::new(None)),
}
}
pub fn menu(&self) -> &MenuState<O> {
&self.menu
}
pub fn node_key(&self) -> Option<NodeKey> {
self.node_key.borrow().clone()
}
pub fn set_node_key(&self, key: Option<NodeKey>) {
*self.node_key.borrow_mut() = key.clone();
let Some(key) = key else {
if self.menu.resolution().is_some() {
self.menu.close();
}
return;
};
let exists = self
.menu
.editor
.get_editor_state()
.read(|| crate::get_node_by_key(&key).is_some());
if exists && self.menu.resolution().is_none() {
self.menu.open(MenuResolution {
text_match: None,
anchor_key: key,
start_offset: 0,
end_offset: 0,
});
}
}
}
#[cfg(all(test, feature = "rich-text"))]
mod tests {
use super::*;
use crate::commands::KEY_TAB_COMMAND;
use crate::editor::COMMAND_PRIORITY_EDITOR;
use crate::{
CreateEditorArgs, create_editor, create_paragraph_node, create_text_node, get_root,
rich_text,
};
use std::cell::Cell;
struct Item(String);
impl MenuOption for Item {
fn key(&self) -> &str {
&self.0
}
}
struct Fixture {
editor: Editor,
menu: MenuState<Item>,
chosen: Rc<RefCell<Vec<String>>>,
_unregister: Vec<Unregister>,
}
impl Fixture {
fn new() -> Self {
let editor = create_editor(CreateEditorArgs {
nodes: rich_text::rich_text_nodes(),
..CreateEditorArgs::default()
});
let rich_text = rich_text::register_rich_text(&editor);
let chosen = Rc::new(RefCell::new(Vec::new()));
let log = chosen.clone();
let (menu, unregister) = register_typeahead_menu::<Item>(
&editor,
basic_typeahead_trigger_match(
"/",
TypeaheadTriggerOptions {
min_length: 0,
allow_whitespace: true,
..TypeaheadTriggerOptions::default()
},
),
Rc::new(|_| {}),
Rc::new(move |option, query, close, _| {
log.borrow_mut().push(option.key().to_owned());
if let Some(query) = query {
query.remove(false)?;
}
close();
Ok(())
}),
TypeaheadMenuOptions::default(),
);
menu.set_options(
["a", "b", "c"]
.into_iter()
.map(|key| Rc::new(Item(key.to_owned())))
.collect(),
);
Fixture {
editor,
menu,
chosen,
_unregister: vec![rich_text, unregister],
}
}
fn type_(&self, text: &str) {
let text = text.to_owned();
self.editor
.update(
move || {
let root = get_root();
root.clear()?;
let paragraph = create_paragraph_node();
let node = create_text_node(&text);
paragraph.append(std::slice::from_ref(&node))?;
root.append(&[paragraph])?;
node.select_end().map(|_| ())
},
UpdateOptions {
discrete: true,
..UpdateOptions::default()
},
)
.unwrap();
}
fn text(&self) -> String {
self.editor.read(|| get_root().get_text_content()).unwrap()
}
fn key(key: &str, shift_key: bool) -> Rc<KeyboardEvent> {
Rc::new(KeyboardEvent {
key: key.to_owned(),
code: key.to_owned(),
shift_key,
..KeyboardEvent::default()
})
}
}
#[test]
fn the_menu_stays_open_while_composing() {
let f = Fixture::new();
f.type_("/q");
assert!(f.menu.resolution().is_some());
let update = |compose: bool| {
f.editor
.update(
move || {
let text = get_root().get_first_descendant().unwrap();
crate::set_composition_key(compose.then_some(text.get_key()));
crate::set_selection(None);
Ok(())
},
UpdateOptions {
discrete: true,
..UpdateOptions::default()
},
)
.unwrap()
};
update(true);
assert!(f.editor.is_composing());
assert!(f.menu.resolution().is_some());
update(false);
assert_eq!(f.menu.resolution(), None);
f.type_("/q");
update(true);
f.editor.set_editable(false);
assert_eq!(f.menu.resolution(), None);
}
#[test]
fn a_close_waits_for_on_close_async() {
let f = Fixture::new();
let log = Rc::new(RefCell::new(Vec::new()));
let pending: Rc<RefCell<Vec<MenuCloseDone>>> = Rc::default();
let (closed, waiting) = (log.clone(), pending.clone());
*f.menu.callbacks().on_close.borrow_mut() =
Some(Rc::new(move || closed.borrow_mut().push("onClose")));
let closed = log.clone();
*f.menu.callbacks().on_close_async.borrow_mut() = Some(Rc::new(move |done| {
closed.borrow_mut().push("onCloseAsync");
waiting.borrow_mut().push(done);
}));
f.type_("/q");
f.editor
.dispatch_command(&KEY_ESCAPE_COMMAND, Fixture::key("Escape", false))
.unwrap();
assert_eq!(*log.borrow(), ["onClose", "onCloseAsync"]);
assert!(f.menu.resolution().is_some());
assert!(
f.editor
.dispatch_command(&KEY_ARROW_DOWN_COMMAND, Fixture::key("ArrowDown", false))
.unwrap()
);
f.menu.close();
assert_eq!(log.borrow().len(), 2);
pending.borrow_mut().pop().unwrap().finish();
assert_eq!(f.menu.resolution(), None);
assert!(
!f.editor
.dispatch_command(&KEY_ARROW_DOWN_COMMAND, Fixture::key("ArrowDown", false))
.unwrap()
);
f.type_("/q");
f.menu.close();
f.type_("/r");
drop(pending.borrow_mut().pop().unwrap());
assert!(f.menu.resolution().is_some());
assert!(
f.editor
.dispatch_command(&KEY_ARROW_DOWN_COMMAND, Fixture::key("ArrowDown", false))
.unwrap()
);
f.menu.close();
drop(pending.borrow_mut().pop().unwrap());
assert_eq!(f.menu.resolution(), None);
}
#[test]
fn arrows_wrap_and_enter_chooses() {
let f = Fixture::new();
f.type_("x /q");
assert_eq!(f.menu.selected_index(), Some(0));
let up = Fixture::key("ArrowUp", false);
assert!(
f.editor
.dispatch_command(&KEY_ARROW_UP_COMMAND, up.clone())
.unwrap()
);
assert!(up.default_prevented());
assert_eq!(f.menu.selected_index(), Some(2));
let scrolled = Rc::new(RefCell::new(Vec::new()));
let log = scrolled.clone();
let _scroll = f.editor.register_command(
&SCROLL_TYPEAHEAD_OPTION_INTO_VIEW_COMMAND,
move |payload, _| {
log.borrow_mut()
.push((payload.index, payload.option.key().to_owned()));
Ok(true)
},
crate::editor::COMMAND_PRIORITY_CRITICAL,
);
let down = || Fixture::key("ArrowDown", false);
assert!(
f.editor
.dispatch_command(&KEY_ARROW_DOWN_COMMAND, down())
.unwrap()
);
assert_eq!(f.menu.selected_index(), Some(0));
f.editor
.dispatch_command(&KEY_ARROW_DOWN_COMMAND, down())
.unwrap();
assert_eq!(
*scrolled.borrow(),
[(0, "a".to_owned()), (1, "b".to_owned())]
);
let enter = Fixture::key("Enter", false);
assert!(
f.editor
.dispatch_command(&KEY_ENTER_COMMAND, Some(enter.clone()))
.unwrap()
);
assert!(enter.default_prevented());
assert_eq!(*f.chosen.borrow(), ["b"]);
assert_eq!(f.text(), "x ");
assert_eq!(f.menu.resolution(), None);
}
#[test]
fn tab_chooses_and_shift_enter_is_left_to_rich_text() {
let f = Fixture::new();
f.type_("/q");
f.editor
.dispatch_command(&KEY_ENTER_COMMAND, Some(Fixture::key("Enter", true)))
.unwrap();
assert!(f.chosen.borrow().is_empty());
f.type_("/q");
let tab = Fixture::key("Tab", false);
assert!(
f.editor
.dispatch_command(&KEY_TAB_COMMAND, tab.clone())
.unwrap()
);
assert!(tab.default_prevented());
assert_eq!(*f.chosen.borrow(), ["a"]);
}
#[test]
fn escape_closes_and_keys_pass_through_when_closed_or_empty() {
let f = Fixture::new();
f.type_("/");
assert!(
f.editor
.dispatch_command(&KEY_ESCAPE_COMMAND, Fixture::key("Escape", false))
.unwrap()
);
assert_eq!(f.menu.resolution(), None);
assert!(
!f.editor
.dispatch_command(&KEY_TAB_COMMAND, Fixture::key("Tab", false))
.unwrap()
);
f.type_("/z");
f.menu.set_options(Vec::new());
let reached_editor = Rc::new(Cell::new(false));
let reached = reached_editor.clone();
let _fallback = f.editor.register_command(
&KEY_ARROW_DOWN_COMMAND,
move |_, _| {
reached.set(true);
Ok(false)
},
COMMAND_PRIORITY_EDITOR,
);
let down = Fixture::key("ArrowDown", false);
assert!(
!f.editor
.dispatch_command(&KEY_ARROW_DOWN_COMMAND, down.clone())
.unwrap()
);
assert!(reached_editor.get());
assert!(!down.default_prevented());
f.editor
.dispatch_command(&KEY_ESCAPE_COMMAND, Fixture::key("Escape", false))
.unwrap();
assert!(f.menu.resolution().is_some());
f.menu.set_draws_empty_menu(true);
let down = Fixture::key("ArrowDown", false);
assert!(
f.editor
.dispatch_command(&KEY_ARROW_DOWN_COMMAND, down.clone())
.unwrap()
);
assert!(down.default_prevented());
assert_eq!(f.menu.selected_index(), None);
}
#[test]
fn commands_are_at_the_menu_priority() {
let f = Fixture::new();
assert_eq!(f.menu.command_priority(), COMMAND_PRIORITY_LOW);
f.type_("/q");
let _above = f.editor.register_command(
&KEY_ARROW_DOWN_COMMAND,
|_, _| Ok(true),
crate::editor::COMMAND_PRIORITY_NORMAL,
);
f.editor
.dispatch_command(&KEY_ARROW_DOWN_COMMAND, Fixture::key("ArrowDown", false))
.unwrap();
assert_eq!(f.menu.selected_index(), Some(0));
}
}