Yehowshua/ZIm
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

fixed binding fallback

Browse source
This commit is contained in:
K Simmons 2022-10-27 12:33:51 -07:00
parent 8d94de8eb2
commit e02199fa2a
2 changed files with 64 additions and 73 deletions
Download patch file Download diff file Expand all files Collapse all files

21
crates/gpui/src/app.rs
View file

@ -1551,17 +1551,18 @@ impl MutableAppContext {
{ {
MatchResult::None => false, MatchResult::None => false,
MatchResult::Pending => true, MatchResult::Pending => true,
MatchResult::Match { view_id, action } => { MatchResult::Matches(matches) => {
if self.handle_dispatch_action_from_effect( for (view_id, action) in matches {
window_id, if self.handle_dispatch_action_from_effect(
Some(view_id), window_id,
action.as_ref(), Some(view_id),
) { action.as_ref(),
self.keystroke_matcher.clear_pending(); ) {
true self.keystroke_matcher.clear_pending();
} else { return true;
false }
} }
false
} }
} }
} else { } else {

116
crates/gpui/src/keymap.rs
View file

@ -13,16 +13,11 @@ extern "C" {
} }
pub struct Matcher { pub struct Matcher {
pending: HashMap<usize, Pending>, pending_views: HashMap<usize, Context>,
pending_keystrokes: Vec<Keystroke>,
keymap: Keymap, keymap: Keymap,
} }
#[derive(Default)]
struct Pending {
keystrokes: Vec<Keystroke>,
context: Option<Context>,
}
#[derive(Default)] #[derive(Default)]
pub struct Keymap { pub struct Keymap {
bindings: Vec<Binding>, bindings: Vec<Binding>,
@ -77,7 +72,7 @@ where
pub enum MatchResult { pub enum MatchResult {
None, None,
Pending, Pending,
Match(Vec<(usize, Box<dyn Action>)>), Matches(Vec<(usize, Box<dyn Action>)>),
} }
impl Debug for MatchResult { impl Debug for MatchResult {
@ -85,10 +80,13 @@ impl Debug for MatchResult {
match self { match self {
MatchResult::None => f.debug_struct("MatchResult2::None").finish(), MatchResult::None => f.debug_struct("MatchResult2::None").finish(),
MatchResult::Pending => f.debug_struct("MatchResult2::Pending").finish(), MatchResult::Pending => f.debug_struct("MatchResult2::Pending").finish(),
MatchResult::Match { view_id, action } => f MatchResult::Matches(matches) => f
.debug_struct("MatchResult::Match") .debug_list()
.field("view_id", view_id) .entries(
.field("action", &action.name()) matches
.iter()
.map(|(view_id, action)| format!("{view_id}, {}", action.name())),
)
.finish(), .finish(),
} }
} }
@ -99,13 +97,14 @@ impl PartialEq for MatchResult {
match (self, other) { match (self, other) {
(MatchResult::None, MatchResult::None) => true, (MatchResult::None, MatchResult::None) => true,
(MatchResult::Pending, MatchResult::Pending) => true, (MatchResult::Pending, MatchResult::Pending) => true,
( (MatchResult::Matches(matches), MatchResult::Matches(other_matches)) => {
MatchResult::Match { view_id, action }, matches.len() == other_matches.len()
MatchResult::Match { && matches.iter().zip(other_matches.iter()).all(
view_id: other_view_id, |((view_id, action), (other_view_id, other_action))| {
action: other_action, view_id == other_view_id && action.eq(other_action.as_ref())
}, },
) => view_id == other_view_id && action.eq(other_action.as_ref()), )
}
_ => false, _ => false,
} }
} }
@ -116,23 +115,24 @@ impl Eq for MatchResult {}
impl Matcher { impl Matcher {
pub fn new(keymap: Keymap) -> Self { pub fn new(keymap: Keymap) -> Self {
Self { Self {
pending: HashMap::new(), pending_views: HashMap::new(),
pending_keystrokes: Vec::new(),
keymap, keymap,
} }
} }
pub fn set_keymap(&mut self, keymap: Keymap) { pub fn set_keymap(&mut self, keymap: Keymap) {
self.pending.clear(); self.clear_pending();
self.keymap = keymap; self.keymap = keymap;
} }
pub fn add_bindings<T: IntoIterator<Item = Binding>>(&mut self, bindings: T) { pub fn add_bindings<T: IntoIterator<Item = Binding>>(&mut self, bindings: T) {
self.pending.clear(); self.clear_pending();
self.keymap.add_bindings(bindings); self.keymap.add_bindings(bindings);
} }
pub fn clear_bindings(&mut self) { pub fn clear_bindings(&mut self) {
self.pending.clear(); self.clear_pending();
self.keymap.clear(); self.keymap.clear();
} }
@ -141,11 +141,12 @@ impl Matcher {
} }
pub fn clear_pending(&mut self) { pub fn clear_pending(&mut self) {
self.pending.clear(); self.pending_keystrokes.clear();
self.pending_views.clear();
} }
pub fn has_pending_keystrokes(&self) -> bool { pub fn has_pending_keystrokes(&self) -> bool {
!self.pending.is_empty() !self.pending_keystrokes.is_empty()
} }
pub fn push_keystroke( pub fn push_keystroke(
@ -156,54 +157,49 @@ impl Matcher {
let mut any_pending = false; let mut any_pending = false;
let mut matched_bindings = Vec::new(); let mut matched_bindings = Vec::new();
let first_keystroke = self.pending.is_empty(); let first_keystroke = self.pending_keystrokes.is_empty();
dbg!(&dispatch_path); self.pending_keystrokes.push(keystroke);
for (view_id, context) in dispatch_path { for (view_id, context) in dispatch_path {
if !first_keystroke && !self.pending.contains_key(&view_id) { // Don't require pending view entry if there are no pending keystrokes
if !first_keystroke && !self.pending_views.contains_key(&view_id) {
continue; continue;
} }
let pending = self.pending.entry(view_id).or_default(); // If there is a previous view context, invalidate that view if it
// has changed
if let Some(pending_context) = pending.context.as_ref() { if let Some(previous_view_context) = self.pending_views.remove(&view_id) {
if pending_context != &context { if previous_view_context != context {
pending.keystrokes.clear(); continue;
} }
} }
pending.keystrokes.push(keystroke.clone());
let mut retain_pending = false;
for binding in self.keymap.bindings.iter().rev() { for binding in self.keymap.bindings.iter().rev() {
if binding.keystrokes.starts_with(&pending.keystrokes) if binding.keystrokes.starts_with(&self.pending_keystrokes)
&& binding && binding
.context_predicate .context_predicate
.as_ref() .as_ref()
.map(|c| c.eval(&context)) .map(|c| c.eval(&context))
.unwrap_or(true) .unwrap_or(true)
{ {
if binding.keystrokes.len() == pending.keystrokes.len() { if binding.keystrokes.len() == self.pending_keystrokes.len() {
self.pending.remove(&view_id);
matched_bindings.push((view_id, binding.action.boxed_clone())); matched_bindings.push((view_id, binding.action.boxed_clone()));
} else { } else {
retain_pending = true; self.pending_views.insert(view_id, context.clone());
pending.context = Some(context.clone()); any_pending = true;
} }
} }
} }
if retain_pending {
any_pending = true;
} else {
self.pending.remove(&view_id);
}
} }
if !matched_bindings.is_empty() { if !matched_bindings.is_empty() {
MatchResult::Match(matched_bindings) self.pending_views.clear();
self.pending_keystrokes.clear();
MatchResult::Matches(matched_bindings)
} else if any_pending { } else if any_pending {
MatchResult::Pending MatchResult::Pending
} else { } else {
self.pending_keystrokes.clear();
MatchResult::None MatchResult::None
} }
} }
@ -520,21 +516,15 @@ mod tests {
matcher.push_keystroke(Keystroke::parse("a")?, dispatch_path.clone()) matcher.push_keystroke(Keystroke::parse("a")?, dispatch_path.clone())
); );
assert_eq!( assert_eq!(
MatchResult::Match { MatchResult::Matches(vec![(1, Box::new(AB))]),
view_id: 1,
action: Box::new(AB)
},
matcher.push_keystroke(Keystroke::parse("b")?, dispatch_path.clone()) matcher.push_keystroke(Keystroke::parse("b")?, dispatch_path.clone())
); );
assert!(matcher.pending.is_empty()); assert!(!matcher.has_pending_keystrokes());
assert_eq!( assert_eq!(
MatchResult::Match { MatchResult::Matches(vec![(2, Box::new(B))]),
view_id: 2,
action: Box::new(B)
},
matcher.push_keystroke(Keystroke::parse("b")?, dispatch_path.clone()) matcher.push_keystroke(Keystroke::parse("b")?, dispatch_path.clone())
); );
assert!(matcher.pending.is_empty()); assert!(!matcher.has_pending_keystrokes());
assert_eq!( assert_eq!(
MatchResult::Pending, MatchResult::Pending,
matcher.push_keystroke(Keystroke::parse("a")?, dispatch_path.clone()) matcher.push_keystroke(Keystroke::parse("a")?, dispatch_path.clone())
@ -543,7 +533,7 @@ mod tests {
MatchResult::None, MatchResult::None,
matcher.push_keystroke(Keystroke::parse("c")?, dispatch_path.clone()) matcher.push_keystroke(Keystroke::parse("c")?, dispatch_path.clone())
); );
assert!(matcher.pending.is_empty()); assert!(!matcher.has_pending_keystrokes());
Ok(()) Ok(())
} }
@ -717,15 +707,15 @@ mod tests {
} }
impl Matcher { impl Matcher {
fn test_keystroke( fn test_keystroke<'a>(
&mut self, &'a mut self,
keystroke: &str, keystroke: &str,
dispatch_path: Vec<(usize, Context)>, dispatch_path: Vec<(usize, Context)>,
) -> Option<Box<dyn Action>> { ) -> Option<Box<dyn Action>> {
if let MatchResult::Match { action, .. } = if let MatchResult::Matches(matches) =
self.push_keystroke(Keystroke::parse(keystroke).unwrap(), dispatch_path) self.push_keystroke(Keystroke::parse(keystroke).unwrap(), dispatch_path)
{ {
Some(action.boxed_clone()) Some(matches[0].1.boxed_clone())
} else { } else {
None None
} }