Struct KeyMods 

pub struct KeyMods { /* private fields */ }

Available on crate feature event only.

🎮 ⊆ A bitfield of key modifiers (Shift, Control…) + extra (repeating, composing).

---

^{📍 ui/event}

^{📦 size_of::<KeyMods>() == 2 bytes / 16 bits}

---

Implementations

impl KeyMods

pub const fn from_web(bits: u8) -> Self

Available on crate feature web only.

Constructs KeyMods from a compact web modifier bitmask.

Bit layout:

• 0: Control
• 1: Shift
• 2: Alt
• 3: Super / Meta
• 4: AltGraph
• 5: CapsLock
• 6: NumLock
• 7: ScrollLock

pub const fn to_web(self) -> u8

Available on crate feature web only.

Converts KeyMods into a compact web modifier bitmask.

Only the web-representable low byte is preserved.

impl KeyMods

Named constants

pub const CONTROL: Self

1 The Control modifier.

pub const SHIFT: Self

1 The Shift modifier.

pub const ALT: Self

1 The Alt modifier.

pub const SUPER: Self

1 The Super modifier.

pub const ALT_GR: Self

1 The AltGraph modifier.

pub const CAPS_LOCK: Self

1 The Caps Lock modifier.

pub const NUM_LOCK: Self

1 The Num Lock modifier.

pub const SCROLL_LOCK: Self

1 The Scroll Lock modifier.

pub const LEVEL5: Self

1 The IsoLevel5Shift modifier.

pub const REPEATING: Self

1 Whether a key event is repeating.

pub const COMPOSING: Self

1 Whether a key event is composing (IME input).

impl KeyMods

Convenience methods derived from each named constant.

pub const fn has_control(self) -> bool

Returns true if CONTROL is present.

pub const fn contains_control(self) -> bool

Returns true if all bits in CONTROL are present.

pub const fn intersects_control(self) -> bool

Returns true if the set shares any bit with CONTROL.

pub const fn with_control(self) -> Self

Returns self with CONTROL inserted.

pub const fn with_control_if(self, condition: bool) -> Self

Returns self with CONTROL inserted if condition is true.

pub const fn without_control(self) -> Self

Returns self with CONTROL removed.

pub const fn set_control(&mut self)

Sets CONTROL.

pub const fn set_control_if(&mut self, condition: bool)

Sets CONTROL if condition is true.

pub const fn unset_control(&mut self)

Unsets CONTROL.

pub const fn has_shift(self) -> bool

Returns true if SHIFT is present.

pub const fn contains_shift(self) -> bool

Returns true if all bits in SHIFT are present.

pub const fn intersects_shift(self) -> bool

Returns true if the set shares any bit with SHIFT.

pub const fn with_shift(self) -> Self

Returns self with SHIFT inserted.

pub const fn with_shift_if(self, condition: bool) -> Self

Returns self with SHIFT inserted if condition is true.

pub const fn without_shift(self) -> Self

Returns self with SHIFT removed.

pub const fn set_shift(&mut self)

Sets SHIFT.

pub const fn set_shift_if(&mut self, condition: bool)

Sets SHIFT if condition is true.

pub const fn unset_shift(&mut self)

Unsets SHIFT.

pub const fn has_alt(self) -> bool

Returns true if ALT is present.

pub const fn contains_alt(self) -> bool

Returns true if all bits in ALT are present.

pub const fn intersects_alt(self) -> bool

Returns true if the set shares any bit with ALT.

pub const fn with_alt(self) -> Self

Returns self with ALT inserted.

pub const fn with_alt_if(self, condition: bool) -> Self

Returns self with ALT inserted if condition is true.

pub const fn without_alt(self) -> Self

Returns self with ALT removed.

pub const fn set_alt(&mut self)

Sets ALT.

pub const fn set_alt_if(&mut self, condition: bool)

Sets ALT if condition is true.

pub const fn unset_alt(&mut self)

Unsets ALT.

pub const fn has_super(self) -> bool

Returns true if SUPER is present.

pub const fn contains_super(self) -> bool

Returns true if all bits in SUPER are present.

pub const fn intersects_super(self) -> bool

Returns true if the set shares any bit with SUPER.

pub const fn with_super(self) -> Self

Returns self with SUPER inserted.

pub const fn with_super_if(self, condition: bool) -> Self

Returns self with SUPER inserted if condition is true.

pub const fn without_super(self) -> Self

Returns self with SUPER removed.

pub const fn set_super(&mut self)

Sets SUPER.

pub const fn set_super_if(&mut self, condition: bool)

Sets SUPER if condition is true.

pub const fn unset_super(&mut self)

Unsets SUPER.

pub const fn has_alt_gr(self) -> bool

Returns true if ALT_GR is present.

pub const fn contains_alt_gr(self) -> bool

Returns true if all bits in ALT_GR are present.

pub const fn intersects_alt_gr(self) -> bool

Returns true if the set shares any bit with ALT_GR.

pub const fn with_alt_gr(self) -> Self

Returns self with ALT_GR inserted.

pub const fn with_alt_gr_if(self, condition: bool) -> Self

Returns self with ALT_GR inserted if condition is true.

pub const fn without_alt_gr(self) -> Self

Returns self with ALT_GR removed.

pub const fn set_alt_gr(&mut self)

Sets ALT_GR.

pub const fn set_alt_gr_if(&mut self, condition: bool)

Sets ALT_GR if condition is true.

pub const fn unset_alt_gr(&mut self)

Unsets ALT_GR.

pub const fn has_caps_lock(self) -> bool

Returns true if CAPS_LOCK is present.

pub const fn contains_caps_lock(self) -> bool

Returns true if all bits in CAPS_LOCK are present.

pub const fn intersects_caps_lock(self) -> bool

Returns true if the set shares any bit with CAPS_LOCK.

pub const fn with_caps_lock(self) -> Self

Returns self with CAPS_LOCK inserted.

pub const fn with_caps_lock_if(self, condition: bool) -> Self

Returns self with CAPS_LOCK inserted if condition is true.

pub const fn without_caps_lock(self) -> Self

Returns self with CAPS_LOCK removed.

pub const fn set_caps_lock(&mut self)

Sets CAPS_LOCK.

pub const fn set_caps_lock_if(&mut self, condition: bool)

Sets CAPS_LOCK if condition is true.

pub const fn unset_caps_lock(&mut self)

Unsets CAPS_LOCK.

pub const fn has_num_lock(self) -> bool

Returns true if NUM_LOCK is present.

pub const fn contains_num_lock(self) -> bool

Returns true if all bits in NUM_LOCK are present.

pub const fn intersects_num_lock(self) -> bool

Returns true if the set shares any bit with NUM_LOCK.

pub const fn with_num_lock(self) -> Self

Returns self with NUM_LOCK inserted.

pub const fn with_num_lock_if(self, condition: bool) -> Self

Returns self with NUM_LOCK inserted if condition is true.

pub const fn without_num_lock(self) -> Self

Returns self with NUM_LOCK removed.

pub const fn set_num_lock(&mut self)

Sets NUM_LOCK.

pub const fn set_num_lock_if(&mut self, condition: bool)

Sets NUM_LOCK if condition is true.

pub const fn unset_num_lock(&mut self)

Unsets NUM_LOCK.

pub const fn has_scroll_lock(self) -> bool

Returns true if SCROLL_LOCK is present.

pub const fn contains_scroll_lock(self) -> bool

Returns true if all bits in SCROLL_LOCK are present.

pub const fn intersects_scroll_lock(self) -> bool

Returns true if the set shares any bit with SCROLL_LOCK.

pub const fn with_scroll_lock(self) -> Self

Returns self with SCROLL_LOCK inserted.

pub const fn with_scroll_lock_if(self, condition: bool) -> Self

Returns self with SCROLL_LOCK inserted if condition is true.

pub const fn without_scroll_lock(self) -> Self

Returns self with SCROLL_LOCK removed.

pub const fn set_scroll_lock(&mut self)

Sets SCROLL_LOCK.

pub const fn set_scroll_lock_if(&mut self, condition: bool)

Sets SCROLL_LOCK if condition is true.

pub const fn unset_scroll_lock(&mut self)

Unsets SCROLL_LOCK.

pub const fn has_level5(self) -> bool

Returns true if LEVEL5 is present.

pub const fn contains_level5(self) -> bool

Returns true if all bits in LEVEL5 are present.

pub const fn intersects_level5(self) -> bool

Returns true if the set shares any bit with LEVEL5.

pub const fn with_level5(self) -> Self

Returns self with LEVEL5 inserted.

pub const fn with_level5_if(self, condition: bool) -> Self

Returns self with LEVEL5 inserted if condition is true.

pub const fn without_level5(self) -> Self

Returns self with LEVEL5 removed.

pub const fn set_level5(&mut self)

Sets LEVEL5.

pub const fn set_level5_if(&mut self, condition: bool)

Sets LEVEL5 if condition is true.

pub const fn unset_level5(&mut self)

Unsets LEVEL5.

pub const fn has_repeating(self) -> bool

Returns true if REPEATING is present.

pub const fn contains_repeating(self) -> bool

Returns true if all bits in REPEATING are present.

pub const fn intersects_repeating(self) -> bool

Returns true if the set shares any bit with REPEATING.

pub const fn with_repeating(self) -> Self

Returns self with REPEATING inserted.

pub const fn with_repeating_if(self, condition: bool) -> Self

Returns self with REPEATING inserted if condition is true.

pub const fn without_repeating(self) -> Self

Returns self with REPEATING removed.

pub const fn set_repeating(&mut self)

Sets REPEATING.

pub const fn set_repeating_if(&mut self, condition: bool)

Sets REPEATING if condition is true.

pub const fn unset_repeating(&mut self)

Unsets REPEATING.

pub const fn has_composing(self) -> bool

Returns true if COMPOSING is present.

pub const fn contains_composing(self) -> bool

Returns true if all bits in COMPOSING are present.

pub const fn intersects_composing(self) -> bool

Returns true if the set shares any bit with COMPOSING.

pub const fn with_composing(self) -> Self

Returns self with COMPOSING inserted.

pub const fn with_composing_if(self, condition: bool) -> Self

Returns self with COMPOSING inserted if condition is true.

pub const fn without_composing(self) -> Self

Returns self with COMPOSING removed.

pub const fn set_composing(&mut self)

Sets COMPOSING.

pub const fn set_composing_if(&mut self, condition: bool)

Sets COMPOSING if condition is true.

pub const fn unset_composing(&mut self)

Unsets COMPOSING.

impl KeyMods

Common set methods

pub const fn new() -> Self

Returns an empty set.

pub const fn from_bits(bits: u16) -> Self

Returns a set from raw bits.

pub const fn bits(self) -> u16

Returns the raw backing bits.

pub const fn all() -> Self

Returns the union of all declared sets.

pub const fn is_empty(self) -> bool

Returns true if no bits are set.

pub const fn is_full(self) -> bool

Returns true if all the declared bits are set.

pub const fn contains(self, other: Self) -> bool

Returns true if all bits in other are also set in self.

pub const fn has(self, other: Self) -> bool

An alias of contains.

pub const fn with(self, other: Self) -> Self

Returns self with other inserted.

pub const fn with_if(self, condition: bool, other: Self) -> Self

Returns self with other inserted if condition is true.

pub const fn without(self, other: Self) -> Self

Returns self with other removed.

pub const fn toggled(self, other: Self) -> Self

Returns self with other toggled.

impl KeyMods

Set operations

pub const fn intersects(self, other: Self) -> bool

Returns true if self and other share any bit.

pub const fn is_subset(self, other: Self) -> bool

Returns true if all bits in self are also set in other.

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

Returns true if all bits in other are also set in self.

pub const fn union(self, other: Self) -> Self

Returns the union of self and other.

pub const fn intersection(self, other: Self) -> Self

Returns the intersection of self and other.

pub const fn difference(self, other: Self) -> Self

Returns the difference of self and other.

pub const fn symmetric_difference(self, other: Self) -> Self

Returns the symmetric difference of self and other.

impl KeyMods

Mutating set operations

pub const fn clear(&mut self)

Clears the set.

pub const fn insert(&mut self, other: Self)

Inserts all bits from other.

pub const fn remove(&mut self, other: Self)

Removes all bits from other.

pub const fn toggle(&mut self, other: Self)

Toggles all bits from other.

Trait Implementations

impl Binary for KeyMods

Formats the set as a binary mask over its declared bit domain.

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

Formats the value using the given formatter.

impl BitAnd for KeyMods

type Output = KeyMods

The resulting type after applying the & operator.

fn bitand(self, rhs: Self) -> Self::Output

Performs the & operation.

impl BitAndAssign for KeyMods

fn bitand_assign(&mut self, rhs: Self)

Performs the &= operation.

impl BitOr for KeyMods

type Output = KeyMods

The resulting type after applying the | operator.

fn bitor(self, rhs: Self) -> Self::Output

Performs the | operation.

impl BitOrAssign for KeyMods

fn bitor_assign(&mut self, rhs: Self)

Performs the |= operation.

impl BitSized<{ $Set::_SET_BIT_SIZE }> for KeyMods

const BIT_SIZE: usize = _

The bit size of this type (only the relevant data part, without padding).

const MIN_BYTE_SIZE: usize = _

The rounded up byte size for this type.

fn bit_size(&self) -> usize

Returns the bit size of this type (only the relevant data part, without padding).

fn min_byte_size(&self) -> usize

Returns the rounded up byte size for this type.

impl BitXor for KeyMods

type Output = KeyMods

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: Self) -> Self::Output

Performs the ^ operation.

impl BitXorAssign for KeyMods

fn bitxor_assign(&mut self, rhs: Self)

Performs the ^= operation.

impl Clone for KeyMods

fn clone(&self) -> KeyMods

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl ConstInit for KeyMods

const INIT: Self

Returns the compile-time “initial value” for a type.

impl Copy for KeyMods

impl Debug for KeyMods

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

Formats the value using the given formatter.

impl DebugExt for KeyMods

where KeyMods: Debug,

type Ctx = ReprMode

The context used to guide formatting.

fn fmt_with(&self, f: &mut Formatter<'_>, ctx: &Self::Ctx) -> FmtResult<()>

Formats self under the given context.

fn debug_with<'a>(&'a self, ctx: &'a Self::Ctx) -> DebugWith<'a, Self>

where Self: Sized,

Wraps self for contextual debug formatting.

impl Default for KeyMods

fn default() -> Self

Returns the “default value” for a type.

impl Display for KeyMods

Formats the set as a prefixed binary mask over its declared bit domain.

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

Formats the value using the given formatter.

impl Eq for KeyMods

impl Hash for KeyMods

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 LowerHex for KeyMods

Formats the set as a hexadecimal mask over its declared bit domain.

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

Formats the value using the given formatter.

impl Not for KeyMods

type Output = KeyMods

The resulting type after applying the ! operator.

fn not(self) -> Self::Output

Performs the unary ! operation.

impl Octal for KeyMods

Formats the set as an octal mask over its declared bit domain.

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

Formats the value using the given formatter.

impl Ord for KeyMods

fn cmp(&self, other: &Self) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl PartialEq for KeyMods

fn eq(&self, other: &Self) -> 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 PartialOrd for KeyMods

fn partial_cmp(&self, other: &Self) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

Tests less than (for self and other) and is used by the < operator.

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

Tests less than or equal to (for self and other) and is used by the <= operator.

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

Tests greater than (for self and other) and is used by the > operator.

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

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl Sub for KeyMods

type Output = KeyMods

The resulting type after applying the - operator.

fn sub(self, rhs: Self) -> Self::Output

Performs the - operation.

impl SubAssign for KeyMods

fn sub_assign(&mut self, rhs: Self)

Performs the -= operation.

impl UpperHex for KeyMods

Formats the set as a hexadecimal mask over its declared bit domain.

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

Formats the value using the given formatter.