Present Servo BGRA hardware surfaces

third_party/gpui/src/keymap/binding.rs

@@ -0,0 +1,143 @@
+use std::rc::Rc;
+
+use crate::{
+    Action, AsKeystroke, DummyKeyboardMapper, InvalidKeystrokeError, KeyBindingContextPredicate,
+    KeybindingKeystroke, Keystroke, PlatformKeyboardMapper, SharedString,
+};
+use smallvec::SmallVec;
+
+/// A keybinding and its associated metadata, from the keymap.
+pub struct KeyBinding {
+    pub(crate) action: Box<dyn Action>,
+    pub(crate) keystrokes: SmallVec<[KeybindingKeystroke; 2]>,
+    pub(crate) context_predicate: Option<Rc<KeyBindingContextPredicate>>,
+    pub(crate) meta: Option<KeyBindingMetaIndex>,
+    /// The json input string used when building the keybinding, if any
+    pub(crate) action_input: Option<SharedString>,
+}
+
+impl Clone for KeyBinding {
+    fn clone(&self) -> Self {
+        KeyBinding {
+            action: self.action.boxed_clone(),
+            keystrokes: self.keystrokes.clone(),
+            context_predicate: self.context_predicate.clone(),
+            meta: self.meta,
+            action_input: self.action_input.clone(),
+        }
+    }
+}
+
+impl KeyBinding {
+    /// Construct a new keybinding from the given data. Panics on parse error.
+    pub fn new<A: Action>(keystrokes: &str, action: A, context: Option<&str>) -> Self {
+        let context_predicate =
+            context.map(|context| KeyBindingContextPredicate::parse(context).unwrap().into());
+        Self::load(
+            keystrokes,
+            Box::new(action),
+            context_predicate,
+            false,
+            None,
+            &DummyKeyboardMapper,
+        )
+        .unwrap()
+    }
+
+    /// Load a keybinding from the given raw data.
+    pub fn load(
+        keystrokes: &str,
+        action: Box<dyn Action>,
+        context_predicate: Option<Rc<KeyBindingContextPredicate>>,
+        use_key_equivalents: bool,
+        action_input: Option<SharedString>,
+        keyboard_mapper: &dyn PlatformKeyboardMapper,
+    ) -> std::result::Result<Self, InvalidKeystrokeError> {
+        let keystrokes: SmallVec<[KeybindingKeystroke; 2]> = keystrokes
+            .split_whitespace()
+            .map(|source| {
+                let keystroke = Keystroke::parse(source)?;
+                Ok(KeybindingKeystroke::new_with_mapper(
+                    keystroke,
+                    use_key_equivalents,
+                    keyboard_mapper,
+                ))
+            })
+            .collect::<std::result::Result<_, _>>()?;
+
+        Ok(Self {
+            keystrokes,
+            action,
+            context_predicate,
+            meta: None,
+            action_input,
+        })
+    }
+
+    /// Set the metadata for this binding.
+    pub fn with_meta(mut self, meta: KeyBindingMetaIndex) -> Self {
+        self.meta = Some(meta);
+        self
+    }
+
+    /// Set the metadata for this binding.
+    pub fn set_meta(&mut self, meta: KeyBindingMetaIndex) {
+        self.meta = Some(meta);
+    }
+
+    /// Check if the given keystrokes match this binding.
+    pub fn match_keystrokes(&self, typed: &[impl AsKeystroke]) -> Option<bool> {
+        if self.keystrokes.len() < typed.len() {
+            return None;
+        }
+
+        for (target, typed) in self.keystrokes.iter().zip(typed.iter()) {
+            if !typed.as_keystroke().should_match(target) {
+                return None;
+            }
+        }
+
+        Some(self.keystrokes.len() > typed.len())
+    }
+
+    /// Get the keystrokes associated with this binding
+    pub fn keystrokes(&self) -> &[KeybindingKeystroke] {
+        self.keystrokes.as_slice()
+    }
+
+    /// Get the action associated with this binding
+    pub fn action(&self) -> &dyn Action {
+        self.action.as_ref()
+    }
+
+    /// Get the predicate used to match this binding
+    pub fn predicate(&self) -> Option<Rc<KeyBindingContextPredicate>> {
+        self.context_predicate.as_ref().map(|rc| rc.clone())
+    }
+
+    /// Get the metadata for this binding
+    pub fn meta(&self) -> Option<KeyBindingMetaIndex> {
+        self.meta
+    }
+
+    /// Get the action input associated with the action for this binding
+    pub fn action_input(&self) -> Option<SharedString> {
+        self.action_input.clone()
+    }
+}
+
+impl std::fmt::Debug for KeyBinding {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("KeyBinding")
+            .field("keystrokes", &self.keystrokes)
+            .field("context_predicate", &self.context_predicate)
+            .field("action", &self.action.name())
+            .finish()
+    }
+}
+
+/// A unique identifier for retrieval of metadata associated with a key binding.
+/// Intended to be used as an index or key into a user-defined store of metadata
+/// associated with the binding, such as the source of the binding.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+pub struct KeyBindingMetaIndex(pub u32);