fix(bindings): fire all matching bindings, honor ReceiveChar

Alacritty's `process_key_bindings` iterates every binding that matches
the (key, mods) pair and runs each one's action, only skipping the
"suppress the underlying char" step when a binding's action is
`ReceiveChar`. We stopped at the first match, so the common default
config that stacks `Ctrl+L → ClearLogNotice` (an alacritty-only UI
action we treat as Unsupported) ahead of `Ctrl+L → chars = "\\f"`
silently consumed the press and never wrote 0x0c.

Mirror alacritty: collect every match, fan them out to dispatch, and
let the key fall through to the PTY only when at least one binding is
`ReceiveChar`.

Author: mathix420

alacritree/src/app.rs

@@ -464,11 +464,19 @@ impl AlacritreeApp {
             let mut actions = Vec::new();
             i.events.retain(|ev| {
                 if let egui::Event::Key { key, pressed: true, modifiers, .. } = ev {
-                    if let Some(action) =
-                        crate::bindings::matches(&self.config.bindings, *key, *modifiers)
-                    {
-                        actions.push(action.clone());
-                        return false;
+                    let matched = crate::bindings::all_matches(
+                        &self.config.bindings,
+                        *key,
+                        *modifiers,
+                    );
+                    if !matched.is_empty() {
+                        let suppress_chars = matched
+                            .iter()
+                            .all(|a| !matches!(a, BindingAction::Named(NamedAction::ReceiveChar)));
+                        for a in matched {
+                            actions.push(a.clone());
+                        }
+                        return !suppress_chars;
                     }
                 }
                 true
@@ -541,6 +549,7 @@ impl AlacritreeApp {
             BindingAction::Named(NamedAction::SelectTab(n)) => self.select_tab(n),
             BindingAction::Named(NamedAction::SelectLastTab) => self.select_last_tab(),
             BindingAction::Named(NamedAction::NoOp) => {},
+            BindingAction::Named(NamedAction::ReceiveChar) => {},
             BindingAction::Named(other) => {
                 self.dispatch_scroll_or_other(other);
             },

alacritree/src/bindings.rs

@@ -47,6 +47,10 @@ pub enum NamedAction {
     Quit,
     /// Used to unbind a key — consumes the press without acting on it.
     NoOp,
+    /// Alacritty's pass-through marker: the matching binding runs (no-op for
+    /// us) but suppress_chars stays off so the key still reaches the PTY.
+    /// Mirrors `Action::ReceiveChar` in `alacritty/src/input/keyboard.rs`.
+    ReceiveChar,
 }
 
 #[derive(Debug, Deserialize)]
@@ -193,8 +197,16 @@ fn default_bindings() -> Vec<KeyBinding> {
     b
 }
 
-pub fn matches(bindings: &[KeyBinding], key: Key, mods: Modifiers) -> Option<&BindingAction> {
-    bindings.iter().find(|b| b.key == key && mods_match(b.mods, mods)).map(|b| &b.action)
+/// Every binding that fires for `(key, mods)`.  Alacritty runs *all* matching
+/// bindings (see `Processor::process_key_bindings`), so the user's typical
+/// pattern of stacking `ClearLogNotice` + `chars = "\f"` on Ctrl+L works:
+/// the first action is our `Unsupported` no-op, the second writes 0x0c.
+pub fn all_matches(
+    bindings: &[KeyBinding],
+    key: Key,
+    mods: Modifiers,
+) -> Vec<&BindingAction> {
+    bindings.iter().filter(|b| b.key == key && mods_match(b.mods, mods)).map(|b| &b.action).collect()
 }
 
 /// Alacritty semantics: `Control|Shift` does not fire on Ctrl alone even though
@@ -408,6 +420,7 @@ fn parse_action(name: &str) -> BindingAction {
         "SelectLastTab" => BindingAction::Named(SelectLastTab),
         "Quit" => BindingAction::Named(Quit),
         "None" => BindingAction::Named(NoOp),
+        "ReceiveChar" => BindingAction::Named(ReceiveChar),
         other => BindingAction::Unsupported(other.to_string()),
     }
 }