Struct egui::Modifiers

pub struct Modifiers {
    pub alt: bool,
    pub ctrl: bool,
    pub shift: bool,
    pub mac_cmd: bool,
    pub command: bool,
}

State of the modifier keys. These must be fed to egui.

The best way to compare Modifiers is by using Modifiers::matches.

NOTE: For cross-platform uses, ALT+SHIFT is a bad combination of modifiers as on mac that is how you type special characters, so those key presses are usually not reported to egui.

Fields

alt: bool

Either of the alt keys are down (option ⌥ on Mac).

ctrl: bool

Either of the control keys are down. When checking for keyboard shortcuts, consider using Self::command instead.

shift: bool

Either of the shift keys are down.

mac_cmd: bool

The Mac ⌘ Command key. Should always be set to false on other platforms.

command: bool

On Windows and Linux, set this to the same value as ctrl. On Mac, this should be set whenever one of the ⌘ Command keys are down (same as mac_cmd). This is so that egui can, for instance, select all text by checking for command + A and it will work on both Mac and Windows.

Implementations

impl Modifiers

pub const NONE: Self = _

pub const ALT: Self = _

pub const CTRL: Self = _

pub const SHIFT: Self = _

pub const ALT_SHIFT: Self = _

👎Deprecated: Use Modifiers::ALT | Modifiers::SHIFT instead

pub const MAC_CMD: Self = _

The Mac ⌘ Command key

pub const COMMAND: Self = _

On Mac: ⌘ Command key, elsewhere: Ctrl key

pub const fn plus(self, rhs: Self) -> Self

assert_eq!(
    Modifiers::CTRL | Modifiers::ALT,
    Modifiers { ctrl: true, alt: true, ..Default::default() }
);
assert_eq!(
    Modifiers::ALT.plus(Modifiers::CTRL),
    Modifiers::CTRL.plus(Modifiers::ALT),
);
assert_eq!(
    Modifiers::CTRL | Modifiers::ALT,
    Modifiers::CTRL.plus(Modifiers::ALT),
);

pub fn is_none(&self) -> bool

pub fn any(&self) -> bool

pub fn all(&self) -> bool

pub fn shift_only(&self) -> bool

Is shift the only pressed button?

pub fn command_only(&self) -> bool

true if only Self::ctrl or only Self::mac_cmd is pressed.

pub fn matches(&self, pattern: Modifiers) -> bool

Check for equality but with proper handling of Self::command.

Example:

if current_modifiers.matches(Modifiers::ALT | Modifiers::SHIFT) {
    // Alt and Shift are pressed, and nothing else
}

Behavior:

assert!(Modifiers::CTRL.matches(Modifiers::CTRL));
assert!(!Modifiers::CTRL.matches(Modifiers::CTRL | Modifiers::SHIFT));
assert!(!(Modifiers::CTRL | Modifiers::SHIFT).matches(Modifiers::CTRL));
assert!((Modifiers::CTRL | Modifiers::COMMAND).matches(Modifiers::CTRL));
assert!((Modifiers::CTRL | Modifiers::COMMAND).matches(Modifiers::COMMAND));
assert!((Modifiers::MAC_CMD | Modifiers::COMMAND).matches(Modifiers::COMMAND));
assert!(!Modifiers::COMMAND.matches(Modifiers::MAC_CMD));

pub fn contains(&self, query: Modifiers) -> bool

Whether another set of modifiers is contained in this set of modifiers with proper handling of Self::command.

assert!(Modifiers::default().contains(Modifiers::default()));
assert!(Modifiers::CTRL.contains(Modifiers::default()));
assert!(Modifiers::CTRL.contains(Modifiers::CTRL));
assert!(Modifiers::CTRL.contains(Modifiers::COMMAND));
assert!(Modifiers::MAC_CMD.contains(Modifiers::COMMAND));
assert!(Modifiers::COMMAND.contains(Modifiers::MAC_CMD));
assert!(Modifiers::COMMAND.contains(Modifiers::CTRL));
assert!(!(Modifiers::ALT | Modifiers::CTRL).contains(Modifiers::SHIFT));
assert!((Modifiers::CTRL | Modifiers::SHIFT).contains(Modifiers::CTRL));
assert!(!Modifiers::CTRL.contains(Modifiers::CTRL | Modifiers::SHIFT));

Trait Implementations

impl BitOr for Modifiers

type Output = Modifiers

The resulting type after applying the | operator.

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

Performs the | operation.

impl Clone for Modifiers

fn clone(&self) -> Modifiers

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Modifiers

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

Formats the value using the given formatter.

impl Default for Modifiers

fn default() -> Modifiers

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for Modifiers

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Hash for Modifiers

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 Modifiers

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

This method tests for self and other values to be equal, and is used by ==.

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

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

impl Serialize for Modifiers

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Copy for Modifiers

impl Eq for Modifiers

impl StructuralEq for Modifiers

impl StructuralPartialEq for Modifiers