Struct Keys 

pub struct Keys { /* private fields */ }

The Keys type is the Rust representation of Slint’s keys primitive type.

It can be created with the @keys macro in Slint and defines which key event(s) activate a KeyBinding.

See also the Slint documentation on Key Bindings.

In .slint files, Keys values are typically created via the @keys(...) macro. From backend code, they can be created from a list of string parts with the similar syntax as the macro:

use i_slint_core::input::Keys;

let save = Keys::from_parts(["Control", "S"])?;
let undo = Keys::from_parts(["Control", "Shift?", "Z"])?;
let f5 = Keys::from_parts(["F5"])?;
let zoom_in = Keys::from_parts(["Control", "Plus"])?;
let euro = Keys::from_parts(["Control", "€"])?;
let empty = Keys::from_parts([])?;  // same as Keys::default()

Parts format

Each element is either a modifier or a key (case-sensitive, matching the @keys macro):

• Modifiers (optional): Control, Alt, Shift, Meta
• Optional modifiers: Shift?, Alt? (match regardless of that modifier’s state)
• Named key (required, exactly one): A named key (Return, Tab, F1, Plus, Space, A–Z, etc.)
• String literal fallback: If no named key matches, the part is treated as a string literal — it must be a single lowercase grapheme cluster (e.g., "€", "é")

Keys with layout-dependent shifted variants (digits Digit0–Digit9, symbols like Plus, Comma, etc.) automatically get Shift? behavior, just like the @keys macro.

Implementations

impl Keys

pub fn from_parts<'a>( parts: impl IntoIterator<Item = &'a str>, ) -> Result<Keys, KeysParseError>

Create a Keys from an iterator of string parts (matching @keys macro syntax).

Each element is either a modifier (Control, Shift, Alt, Meta, Shift?, Alt?) or a key. Keys are first looked up by name (case-sensitive) in the Key namespace; if not found, treated as a string literal (must be a single lowercase grapheme cluster). Exactly one non-modifier key must be present.

An empty iterator returns Keys::default() (same as @keys()).

See also the Slint documentation on Key Bindings.

Note: This currently only supports a single shortcut (one key + modifiers).

Trait Implementations

impl Clone for Keys

fn clone(&self) -> Keys

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Keys

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

Formats the keyboard shortcut so that the output would be accepted by the @keys macro in Slint.

impl Default for Keys

fn default() -> Keys

Returns the “default value” for a type.

impl Display for Keys

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

Converts the Keys to a string that looks native on the current platform.

For example, the shortcut created with @keys(Meta + Control + A) will be converted like this:

• macOS: ⌃⌘A
• Windows: Win+Ctrl+A
• Linux: Super+Ctrl+A

Note that this functions output is best-effort and may be adjusted/improved at any time, do not rely on this output to be stable!

impl From<Keys> for Value

fn from(v: Keys) -> Self

Converts to this type from the input type.

impl PartialEq for Keys

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

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl TryFrom<Value> for Keys

type Error = Value

The type returned in the event of a conversion error.

fn try_from(v: Value) -> Result<Keys, Self::Error>

Performs the conversion.

impl Eq for Keys

impl StructuralPartialEq for Keys