1use crate::{
2 Action, ActionRegistry, DispatchPhase, FocusId, KeyBinding, KeyContext, KeyMatch, Keymap,
3 Keystroke, KeystrokeMatcher, WindowContext,
4};
5use collections::HashMap;
6use parking_lot::Mutex;
7use smallvec::SmallVec;
8use std::{
9 any::{Any, TypeId},
10 rc::Rc,
11 sync::Arc,
12};
13
14#[derive(Clone, Copy, Debug, Eq, PartialEq, Hash)]
15pub struct DispatchNodeId(usize);
16
17pub(crate) struct DispatchTree {
18 node_stack: Vec<DispatchNodeId>,
19 context_stack: Vec<KeyContext>,
20 nodes: Vec<DispatchNode>,
21 focusable_node_ids: HashMap<FocusId, DispatchNodeId>,
22 keystroke_matchers: HashMap<SmallVec<[KeyContext; 4]>, KeystrokeMatcher>,
23 keymap: Arc<Mutex<Keymap>>,
24 action_registry: Rc<ActionRegistry>,
25}
26
27#[derive(Default)]
28pub(crate) struct DispatchNode {
29 pub key_listeners: SmallVec<[KeyListener; 2]>,
30 pub action_listeners: SmallVec<[DispatchActionListener; 16]>,
31 pub context: KeyContext,
32 parent: Option<DispatchNodeId>,
33}
34
35type KeyListener = Rc<dyn Fn(&dyn Any, DispatchPhase, &mut WindowContext)>;
36
37#[derive(Clone)]
38pub(crate) struct DispatchActionListener {
39 pub(crate) action_type: TypeId,
40 pub(crate) listener: Rc<dyn Fn(&dyn Any, DispatchPhase, &mut WindowContext)>,
41}
42
43impl DispatchTree {
44 pub fn new(keymap: Arc<Mutex<Keymap>>, action_registry: Rc<ActionRegistry>) -> Self {
45 Self {
46 node_stack: Vec::new(),
47 context_stack: Vec::new(),
48 nodes: Vec::new(),
49 focusable_node_ids: HashMap::default(),
50 keystroke_matchers: HashMap::default(),
51 keymap,
52 action_registry,
53 }
54 }
55
56 pub fn clear(&mut self) {
57 self.node_stack.clear();
58 self.nodes.clear();
59 self.context_stack.clear();
60 self.focusable_node_ids.clear();
61 self.keystroke_matchers.clear();
62 }
63
64 pub fn push_node(&mut self, context: KeyContext) {
65 let parent = self.node_stack.last().copied();
66 let node_id = DispatchNodeId(self.nodes.len());
67 self.nodes.push(DispatchNode {
68 parent,
69 ..Default::default()
70 });
71 self.node_stack.push(node_id);
72 if !context.is_empty() {
73 self.active_node().context = context.clone();
74 self.context_stack.push(context);
75 }
76 }
77
78 pub fn pop_node(&mut self) {
79 let node_id = self.node_stack.pop().unwrap();
80 if !self.nodes[node_id.0].context.is_empty() {
81 self.context_stack.pop();
82 }
83 }
84
85 pub fn clear_keystroke_matchers(&mut self) {
86 self.keystroke_matchers.clear();
87 }
88
89 /// Preserve keystroke matchers from previous frames to support multi-stroke
90 /// bindings across multiple frames.
91 pub fn preserve_keystroke_matchers(&mut self, old_tree: &mut Self, focus_id: Option<FocusId>) {
92 if let Some(node_id) = focus_id.and_then(|focus_id| self.focusable_node_id(focus_id)) {
93 let dispatch_path = self.dispatch_path(node_id);
94
95 self.context_stack.clear();
96 for node_id in dispatch_path {
97 let node = self.node(node_id);
98 if !node.context.is_empty() {
99 self.context_stack.push(node.context.clone());
100 }
101
102 if let Some((context_stack, matcher)) = old_tree
103 .keystroke_matchers
104 .remove_entry(self.context_stack.as_slice())
105 {
106 self.keystroke_matchers.insert(context_stack, matcher);
107 }
108 }
109 }
110 }
111
112 pub fn on_key_event(&mut self, listener: KeyListener) {
113 self.active_node().key_listeners.push(listener);
114 }
115
116 pub fn on_action(
117 &mut self,
118 action_type: TypeId,
119 listener: Rc<dyn Fn(&dyn Any, DispatchPhase, &mut WindowContext)>,
120 ) {
121 self.active_node()
122 .action_listeners
123 .push(DispatchActionListener {
124 action_type,
125 listener,
126 });
127 }
128
129 pub fn make_focusable(&mut self, focus_id: FocusId) {
130 self.focusable_node_ids
131 .insert(focus_id, self.active_node_id());
132 }
133
134 pub fn focus_contains(&self, parent: FocusId, child: FocusId) -> bool {
135 if parent == child {
136 return true;
137 }
138
139 if let Some(parent_node_id) = self.focusable_node_ids.get(&parent) {
140 let mut current_node_id = self.focusable_node_ids.get(&child).copied();
141 while let Some(node_id) = current_node_id {
142 if node_id == *parent_node_id {
143 return true;
144 }
145 current_node_id = self.nodes[node_id.0].parent;
146 }
147 }
148 false
149 }
150
151 pub fn available_actions(&self, target: FocusId) -> Vec<Box<dyn Action>> {
152 let mut actions = Vec::new();
153 if let Some(node) = self.focusable_node_ids.get(&target) {
154 for node_id in self.dispatch_path(*node) {
155 let node = &self.nodes[node_id.0];
156 for DispatchActionListener { action_type, .. } in &node.action_listeners {
157 // Intentionally silence these errors without logging.
158 // If an action cannot be built by default, it's not available.
159 actions.extend(self.action_registry.build_action_type(action_type).ok());
160 }
161 }
162 }
163 actions
164 }
165
166 pub fn bindings_for_action(&self, action: &dyn Action) -> Vec<KeyBinding> {
167 self.keymap
168 .lock()
169 .bindings_for_action(action.type_id())
170 .filter(|candidate| candidate.action.partial_eq(action))
171 .cloned()
172 .collect()
173 }
174
175 pub fn dispatch_key(
176 &mut self,
177 keystroke: &Keystroke,
178 context: &[KeyContext],
179 ) -> Option<Box<dyn Action>> {
180 if !self.keystroke_matchers.contains_key(context) {
181 let keystroke_contexts = context.iter().cloned().collect();
182 self.keystroke_matchers.insert(
183 keystroke_contexts,
184 KeystrokeMatcher::new(self.keymap.clone()),
185 );
186 }
187
188 let keystroke_matcher = self.keystroke_matchers.get_mut(context).unwrap();
189 if let KeyMatch::Some(action) = keystroke_matcher.match_keystroke(keystroke, context) {
190 // Clear all pending keystrokes when an action has been found.
191 for keystroke_matcher in self.keystroke_matchers.values_mut() {
192 keystroke_matcher.clear_pending();
193 }
194
195 Some(action)
196 } else {
197 None
198 }
199 }
200
201 pub fn dispatch_path(&self, target: DispatchNodeId) -> SmallVec<[DispatchNodeId; 32]> {
202 let mut dispatch_path: SmallVec<[DispatchNodeId; 32]> = SmallVec::new();
203 let mut current_node_id = Some(target);
204 while let Some(node_id) = current_node_id {
205 dispatch_path.push(node_id);
206 current_node_id = self.nodes[node_id.0].parent;
207 }
208 dispatch_path.reverse(); // Reverse the path so it goes from the root to the focused node.
209 dispatch_path
210 }
211
212 pub fn node(&self, node_id: DispatchNodeId) -> &DispatchNode {
213 &self.nodes[node_id.0]
214 }
215
216 fn active_node(&mut self) -> &mut DispatchNode {
217 let active_node_id = self.active_node_id();
218 &mut self.nodes[active_node_id.0]
219 }
220
221 pub fn focusable_node_id(&self, target: FocusId) -> Option<DispatchNodeId> {
222 self.focusable_node_ids.get(&target).copied()
223 }
224
225 fn active_node_id(&self) -> DispatchNodeId {
226 *self.node_stack.last().unwrap()
227 }
228}