Enum KeyBindingContextPredicate 

pub enum KeyBindingContextPredicate {
    Identifier(SharedString),
    Equal(SharedString, SharedString),
    NotEqual(SharedString, SharedString),
    Descendant(Box<KeyBindingContextPredicate>, Box<KeyBindingContextPredicate>),
    Not(Box<KeyBindingContextPredicate>),
    And(Box<KeyBindingContextPredicate>, Box<KeyBindingContextPredicate>),
    Or(Box<KeyBindingContextPredicate>, Box<KeyBindingContextPredicate>),
}

A condition on the key context stack that decides whether a binding applies.

A predicate is written in a small language, such as Editor && mode == insert, and is evaluated against the KeyContexts on the focus path. Build one with KeyBindingContextPredicate::parse.

Display writes the predicate in the same syntax. It adds parentheses around || inside && and around negated groups. Descendant expressions are written without parentheses around their operands, so add parentheses yourself when combining > with && or || in text that must round-trip through parse.

Examples

let predicate = KeyBindingContextPredicate::parse("Editor && mode == insert").unwrap();
assert_eq!(predicate.to_string(), "Editor && mode == insert");

let stack = [
    KeyContext::parse("Workspace").unwrap(),
    KeyContext::parse("Editor mode=insert").unwrap(),
];
assert_eq!(predicate.depth_of(&stack), Some(2));

Variants

Identifier(SharedString)

Matches a context that has an entry named by the identifier, with or without a value.

Equal(SharedString, SharedString)

Matches a context whose entry for the key has the given value. Written key == value.

NotEqual(SharedString, SharedString)

Matches unless the context’s entry for the key has the given value. Written key != value. Also matches when the context has no entry for the key.

Descendant(Box<KeyBindingContextPredicate>, Box<KeyBindingContextPredicate>)

Matches when the first predicate matches an ancestor context and the second matches the contexts beneath it. Written parent > child.

Not(Box<KeyBindingContextPredicate>)

Matches when the inner predicate doesn’t match. Written !inner.

And(Box<KeyBindingContextPredicate>, Box<KeyBindingContextPredicate>)

Matches when both predicates match. Written left && right.

Or(Box<KeyBindingContextPredicate>, Box<KeyBindingContextPredicate>)

Matches when either predicate matches. Written left || right.

Implementations

impl KeyBindingContextPredicate

pub fn parse(source: &str) -> Result<Self>

Parses a predicate such as Editor && !ReadOnly or Panel > Editor.

The grammar, from the tightest-binding rule to the loosest, is:

• Atoms. An identifier, such as Editor, matches a context with that name. An identifier is letters, digits, _ and -. The characters >, <, ~, " and ? can also appear after the first character, so write Panel > Editor with spaces. The text Panel>Editor is one identifier.
• Parentheses. ( ... ) groups a predicate.
• Negation. ! applies to the atom or parenthesized group after it, so !a && b is (!a) && b. Use !(a && b) to negate a group.
• Equality. key == value and key != value compare the value of an entry. Both sides must be plain identifiers, so mode == "full" is an error.
• && binds tighter than ||. So a || b && c is a || (b && c).
• Descendant. parent > child binds loosest, so a && b > c is (a && b) > c. It is left-associative: A > B > C is (A > B) > C.

The keymap guide has the same rules as a table.

Errors

Returns an error for an unbalanced parenthesis, a missing operand, an operator the grammar doesn’t have, a == or != whose operands aren’t identifiers, or any leftover text.

Examples

let predicate = KeyBindingContextPredicate::parse("Pane > (Editor || Terminal) && !ReadOnly")
    .unwrap();
assert_eq!(predicate.to_string(), "Pane > (Editor || Terminal) && !ReadOnly");
assert!(KeyBindingContextPredicate::parse("mode == \"full\"").is_err());

See contexts and keyboard input for when contexts apply.

pub fn depth_of(&self, contexts: &[KeyContext]) -> Option<usize>

Returns the deepest depth at which the predicate matches contexts, or None if it matches none.

A depth d means the predicate matches the first d contexts, with the dth as the deepest one that identifiers and == look at. The keymap uses this depth to rank bindings: a deeper match wins. A predicate that matches only at a shallower depth is returned at that depth.

Examples

let predicate = KeyBindingContextPredicate::parse("Workspace").unwrap();
let stack = [
    KeyContext::parse("Workspace").unwrap(),
    KeyContext::parse("Editor").unwrap(),
];
assert_eq!(predicate.depth_of(&stack), Some(1));
assert_eq!(predicate.depth_of(&stack[1..]), None);

pub fn eval(&self, contexts: &[KeyContext]) -> bool

Returns whether the predicate matches the whole of contexts, which is ordered from the root to the focused element.

pub fn eval_inner( &self, contexts: &[KeyContext], all_contexts: &[KeyContext], ) -> bool

Returns whether the predicate matches the prefix contexts, ordered from the root to the focused element. all_contexts is the full stack, which ! checks against.

Callers that want the whole stack use eval. depth_of calls this with each prefix.

pub fn is_superset(&self, other: &Self) -> bool

Returns whether every context that other matches is also matched by self.

The check is conservative. true is certain, but false means only that this check couldn’t show it. The keymap uses it to check whether a disabling binding’s context covers the context of the binding it disables.

Examples

let editor = KeyBindingContextPredicate::parse("Editor").unwrap();
let editor_and_vim = KeyBindingContextPredicate::parse("Editor && vim_mode").unwrap();
assert!(editor.is_superset(&editor_and_vim));
assert!(!editor_and_vim.is_superset(&editor));

Trait Implementations

impl Clone for KeyBindingContextPredicate

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for KeyBindingContextPredicate

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Display for KeyBindingContextPredicate

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Eq for KeyBindingContextPredicate

impl Hash for KeyBindingContextPredicate

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for KeyBindingContextPredicate

fn eq(&self, other: &Self) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl StructuralPartialEq for KeyBindingContextPredicate