Struct egui::input_state::InputState

pub struct InputState {

    pub raw: RawInput,
    pub pointer: PointerState,
    touch_states: BTreeMap<TouchDeviceId, TouchState>,
    last_scroll_time: f64,
    unprocessed_scroll_delta: Vec2,
    unprocessed_scroll_delta_for_zoom: f32,
    pub raw_scroll_delta: Vec2,
    pub smooth_scroll_delta: Vec2,
    zoom_factor_delta: f32,
    pub screen_rect: Rect,
    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>,
    input_options: InputOptions,
}

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.

touch_states: BTreeMap<TouchDeviceId, TouchState>

State of touches, except those covered by PointerState (like clicks and drags). (We keep a separate TouchState for each encountered touch device.)

last_scroll_time: f64

Time of the last scroll event.

unprocessed_scroll_delta: Vec2

Used for smoothing the scroll delta.

unprocessed_scroll_delta_for_zoom: f32

Used for smoothing the scroll delta when zooming.

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.

zoom_factor_delta: f32

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

screen_rect: Rect

Position and size of the egui area.

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

input_options: InputOptions

Input state management configuration.

This gets copied from egui::Options at the start of each frame for convenience.

Implementations

impl InputState

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

pub fn viewport(&self) -> &ViewportInfo

Info about the active viewport

pub fn screen_rect(&self) -> Rect

pub fn zoom_delta(&self) -> f32

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

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 time_since_last_scroll(&self) -> f32

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

pub fn wants_repaint_after(&self) -> Option<Duration>

The crate::Context will call this at the end of each frame to see if we need a repaint.

Returns how long to wait for a repaint.

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.

fn create_touch_states_for_new_devices(&mut self, events: &[Event])

Scans events for device IDs of touch devices we have not seen before, and creates a new TouchState for each such device.

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

Get all events that matches the given filter.

pub(crate) fn is_long_touch(&self) -> bool

A long press is something we detect on touch screens to trigger a secondary click (context menu).

Returns true only on one frame.

impl InputState

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

Trait Implementations

impl Clone for InputState

fn clone(&self) -> InputState

Returns a copy 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.