Struct KeyContext 

pub struct KeyContext(/* private fields */);

The names and values that describe one element, for matching key bindings.

An element sets its context with InteractiveElement::key_context, and GPUI collects the contexts along the focus path into a stack. A binding’s predicate is then matched against that stack. A context holds identifiers, such as Editor, and key-value pairs, such as mode=full.

Examples

let context = KeyContext::parse("Editor mode=full").unwrap();
assert!(context.contains("Editor"));
assert_eq!(context.get("mode"), Some(&SharedString::from("full")));
assert_eq!(context.get("Editor"), None);

Implementations

impl KeyContext

pub fn new_with_defaults() -> Self

Creates an empty context that already has an os entry for the current platform.

The value is macos, linux, windows or unknown, so a binding can use os == macos to apply on one platform only.

pub fn primary(&self) -> Option<&ContextEntry>

Returns the first identifier without a value, which names the element in the usual context convention. Returns None if there is no identifier.

pub fn secondary(&self) -> impl Iterator<Item = &ContextEntry>

Returns every entry except the one primary returns.

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

Parses a context such as Editor or Editor mode=full.

The text is a list of entries separated by whitespace. Each entry is either an identifier, such as Editor, or a key-value pair written key=value or key = value. Identifier characters are letters, digits, _ and -. An entry whose key is already present is ignored, so the first one wins. Returns an error for text that isn’t a list of such entries, such as . or =insert.

This takes entries only. Operators such as && and > aren’t part of this format. Use KeyBindingContextPredicate::parse to write a predicate.

Examples

let context = KeyContext::parse("Panel Editor mode = insert").unwrap();
assert!(context.contains("Panel"));
assert_eq!(context.primary().unwrap().key, SharedString::from("Panel"));

pub fn is_empty(&self) -> bool

Returns whether this context has no entries.

pub fn clear(&mut self)

Removes every entry.

pub fn extend(&mut self, other: &Self)

Adds each entry of other whose key this context doesn’t already have.

pub fn add<I: Into<SharedString>>(&mut self, identifier: I)

Adds an identifier, unless this context already has an entry with that key.

pub fn set<S1: Into<SharedString>, S2: Into<SharedString>>( &mut self, key: S1, value: S2, )

Adds a key-value pair, unless this context already has an entry with that key.

pub fn contains(&self, key: &str) -> bool

Returns whether this context has an entry with key, whether or not that entry has a value.

pub fn get(&self, key: &str) -> Option<&SharedString>

Returns the value of the first entry with key. Returns None if there is no such entry, or if the entry is a plain identifier.

Trait Implementations

impl Clone for KeyContext

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 KeyContext

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

Formats the value using the given formatter.

impl Default for KeyContext

fn default() -> Self

Returns the “default value” for a type.

impl Eq for KeyContext

impl Hash for KeyContext

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 KeyContext

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

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for KeyContext

impl<'a> TryFrom<&'a str> for KeyContext

type Error = Error

The type returned in the event of a conversion error.

fn try_from(value: &'a str) -> Result<Self>

Performs the conversion.