Struct InputState 

pub struct InputState {

    pub raw: RawInput,
    pub pointer: PointerState,
    pub raw_scroll_delta: Vec2,
    pub smooth_scroll_delta: Vec2,
    pub pixels_per_point: f32,
    pub max_texture_side: usize,
    pub time: f64,
    pub unstable_dt: f32,
    pub predicted_dt: f32,
    pub stable_dt: f32,
    pub focused: bool,
    pub modifiers: Modifiers,
    pub keys_down: HashSet<Key>,
    pub events: Vec<Event>,
    /* private fields */
}

Input state that egui updates each frame.

You can access this with crate::Context::input.

You can check if egui is using the inputs using crate::Context::wants_pointer_input and crate::Context::wants_keyboard_input.

Fields

raw: RawInput

The raw input we got this frame from the backend.

pointer: PointerState

State of the mouse or simple touch gestures which can be mapped to mouse operations.

raw_scroll_delta: Vec2

You probably want to use Self::smooth_scroll_delta instead.

The raw input of how many points the user scrolled.

The delta dictates how the content should move.

A positive X-value indicates the content is being moved right, as when swiping right on a touch-screen or track-pad with natural scrolling.

A positive Y-value indicates the content is being moved down, as when swiping down on a touch-screen or track-pad with natural scrolling.

When using a notched scroll-wheel this will spike very large for one frame, then drop to zero. For a smoother experience, use Self::smooth_scroll_delta.

smooth_scroll_delta: Vec2

How many points the user scrolled, smoothed over a few frames.

The delta dictates how the content should move.

A positive X-value indicates the content is being moved right, as when swiping right on a touch-screen or track-pad with natural scrolling.

A positive Y-value indicates the content is being moved down, as when swiping down on a touch-screen or track-pad with natural scrolling.

crate::ScrollArea will both read and write to this field, so that at the end of the frame this will be zero if a scroll-area consumed the delta.

pixels_per_point: f32

Also known as device pixel ratio, > 1 for high resolution screens.

max_texture_side: usize

Maximum size of one side of a texture.

This depends on the backend.

time: f64

Time in seconds. Relative to whatever. Used for animation.

unstable_dt: f32

Time since last frame, in seconds.

This can be very unstable in reactive mode (when we don’t paint each frame). For animations it is therefore better to use Self::stable_dt.

predicted_dt: f32

Estimated time until next frame (provided we repaint right away).

Used for animations to get instant feedback (avoid frame delay). Should be set to the expected time between frames when painting at vsync speeds.

On most integrations this has a fixed value of 1.0 / 60.0, so it is not a very accurate estimate.

stable_dt: f32

Time since last frame (in seconds), but gracefully handles the first frame after sleeping in reactive mode.

In reactive mode (available in e.g. eframe), egui only updates when there is new input or something is animating. This can lead to large gaps of time (sleep), leading to large Self::unstable_dt.

If egui requested a repaint the previous frame, then egui will use stable_dt = unstable_dt;, but if egui did not not request a repaint last frame, then egui will assume unstable_dt is too large, and will use stable_dt = predicted_dt;.

This means that for the first frame after a sleep, stable_dt will be a prediction of the delta-time until the next frame, and in all other situations this will be an accurate measurement of time passed since the previous frame.

Note that a frame can still stall for various reasons, so stable_dt can still be unusually large in some situations.

When animating something, it is recommended that you use something like stable_dt.min(0.1) - this will give you smooth animations when the framerate is good (even in reactive mode), but will avoid large jumps when framerate is bad, and will effectively slow down the animation when FPS drops below 10.

focused: bool

The native window has the keyboard focus (i.e. is receiving key presses).

False when the user alt-tab away from the application, for instance.

modifiers: Modifiers

Which modifier keys are down at the start of the frame?

keys_down: HashSet<Key>

events: Vec<Event>

In-order events received this frame

Implementations

impl InputState

pub fn begin_pass( self, new: RawInput, requested_immediate_repaint_prev_frame: bool, pixels_per_point: f32, options: InputOptions, ) -> Self

pub fn viewport(&self) -> &ViewportInfo

Info about the active viewport

pub fn content_rect(&self) -> Rect

Returns the region of the screen that is safe for content rendering

Returns the viewport_rect with the safe_area_insets removed.

If you want to render behind e.g. the dynamic island on iOS, use Self::viewport_rect.

See also RawInput::safe_area_insets.

pub fn viewport_rect(&self) -> Rect

Returns the full area available to egui, including parts that might be partially covered, for example, by the OS status bar or notches (see Self::safe_area_insets).

Usually you want to use Self::content_rect instead.

This rectangle includes e.g. the dynamic island on iOS. If you want to only render below the that (not behind), then you should use Self::content_rect instead.

See also RawInput::safe_area_insets.

pub fn screen_rect(&self) -> Rect

👎Deprecated: screen_rect has been split into viewport_rect() and content_rect(). You likely should use content_rect()

Position and size of the egui area.

pub fn safe_area_insets(&self) -> SafeAreaInsets

Get the safe area insets.

This represents the area of the screen covered by status bars, navigation controls, notches, or other items that obscure part of the screen.

See Self::content_rect to get the viewport_rect with the safe area insets removed.

pub fn zoom_delta(&self) -> f32

Uniform zoom scale factor this frame (e.g. from ctrl-scroll or pinch gesture).

• zoom = 1: no change
• zoom < 1: pinch together
• zoom > 1: pinch spread

If your application supports non-proportional zooming, then you probably want to use Self::zoom_delta_2d instead.

pub fn zoom_delta_2d(&self) -> Vec2

2D non-proportional zoom scale factor this frame (e.g. from ctrl-scroll or pinch gesture).

For multitouch devices the user can do a horizontal or vertical pinch gesture. In these cases a non-proportional zoom factor is a available. In other cases, this reverts to Vec2::splat(self.zoom_delta()).

For horizontal pinches, this will return [z, 1], for vertical pinches this will return [1, z], and otherwise this will return [z, z], where z is the zoom factor:

• zoom = 1: no change
• zoom < 1: pinch together
• zoom > 1: pinch spread

pub fn rotation_delta(&self) -> f32

Rotation in radians this frame, measuring clockwise (e.g. from a rotation gesture).

pub fn translation_delta(&self) -> Vec2

Panning translation in pixels this frame (e.g. from scrolling or a pan gesture)

The delta indicates how the content should move.

A positive X-value indicates the content is being moved right, as when swiping right on a touch-screen or track-pad with natural scrolling.

A positive Y-value indicates the content is being moved down, as when swiping down on a touch-screen or track-pad with natural scrolling.

pub fn time_since_last_scroll(&self) -> f32

How long has it been (in seconds) since the use last scrolled?

pub fn count_and_consume_key( &mut self, modifiers: Modifiers, logical_key: Key, ) -> usize

Count presses of a key. If non-zero, the presses are consumed, so that this will only return non-zero once.

Includes key-repeat events.

This uses Modifiers::matches_logically to match modifiers, meaning extra Shift and Alt modifiers are ignored. Therefore, you should match most specific shortcuts first, i.e. check for Cmd-Shift-S (“Save as…”) before Cmd-S (“Save”), so that a user pressing Cmd-Shift-S won’t trigger the wrong command!

pub fn consume_key(&mut self, modifiers: Modifiers, logical_key: Key) -> bool

Check for a key press. If found, true is returned and the key pressed is consumed, so that this will only return true once.

Includes key-repeat events.

This uses Modifiers::matches_logically to match modifiers, meaning extra Shift and Alt modifiers are ignored. Therefore, you should match most specific shortcuts first, i.e. check for Cmd-Shift-S (“Save as…”) before Cmd-S (“Save”), so that a user pressing Cmd-Shift-S won’t trigger the wrong command!

pub fn consume_shortcut(&mut self, shortcut: &KeyboardShortcut) -> bool

Check if the given shortcut has been pressed.

If so, true is returned and the key pressed is consumed, so that this will only return true once.

This uses Modifiers::matches_logically to match modifiers, meaning extra Shift and Alt modifiers are ignored. Therefore, you should match most specific shortcuts first, i.e. check for Cmd-Shift-S (“Save as…”) before Cmd-S (“Save”), so that a user pressing Cmd-Shift-S won’t trigger the wrong command!

pub fn key_pressed(&self, desired_key: Key) -> bool

Was the given key pressed this frame?

Includes key-repeat events.

pub fn num_presses(&self, desired_key: Key) -> usize

How many times was the given key pressed this frame?

Includes key-repeat events.

pub fn key_down(&self, desired_key: Key) -> bool

Is the given key currently held down?

pub fn key_released(&self, desired_key: Key) -> bool

Was the given key released this frame?

pub fn pixels_per_point(&self) -> f32

Also known as device pixel ratio, > 1 for high resolution screens.

pub fn physical_pixel_size(&self) -> f32

Size of a physical pixel in logical gui coordinates (points).

pub fn aim_radius(&self) -> f32

How imprecise do we expect the mouse/touch input to be? Returns imprecision in points.

pub fn multi_touch(&self) -> Option<MultiTouchInfo>

Returns details about the currently ongoing multi-touch gesture, if any. Note that this method returns None for single-touch gestures (click, drag, …).

let mut zoom = 1.0; // no zoom
let mut rotation = 0.0; // no rotation
let multi_touch = ui.input(|i| i.multi_touch());
if let Some(multi_touch) = multi_touch {
    zoom *= multi_touch.zoom_delta;
    rotation += multi_touch.rotation_delta;
}
let transform = zoom * Rot2::from_angle(rotation);

By far not all touch devices are supported, and the details depend on the egui integration backend you are using. eframe web supports multi touch for most mobile devices, but not for a Trackpad on MacOS, for example. The backend has to be able to capture native touch events, but many browsers seem to pass such events only for touch screens, but not touch pads.

Refer to MultiTouchInfo for details about the touch information available.

Consider using zoom_delta() instead of MultiTouchInfo::zoom_delta as the former delivers a synthetic zoom factor based on ctrl-scroll events, as a fallback.

pub fn any_touches(&self) -> bool

True if there currently are any fingers touching egui.

pub fn has_touch_screen(&self) -> bool

True if we have ever received a touch event.

pub fn accesskit_action_requests( &self, id: Id, action: Action, ) -> impl Iterator<Item = &ActionRequest>

pub fn consume_accesskit_action_requests( &mut self, id: Id, consume: impl FnMut(&ActionRequest) -> bool, )

pub fn has_accesskit_action_request(&self, id: Id, action: Action) -> bool

pub fn num_accesskit_action_requests(&self, id: Id, action: Action) -> usize

pub fn filtered_events(&self, filter: &EventFilter) -> Vec<Event>

Get all events that matches the given filter.

impl InputState

pub fn ui(&self, ui: &mut Ui)

Trait Implementations

impl Clone for InputState

fn clone(&self) -> InputState

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for InputState

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

Formats the value using the given formatter.

impl Default for InputState

fn default() -> Self

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for InputState

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for InputState

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

where __S: Serializer,

Serialize this value into the given Serde serializer.