Struct egui::InputState[−][src]

pub struct InputState {
    pub raw: RawInput,
    pub pointer: PointerState,
    pub scroll_delta: Vec2,
    pub screen_rect: Rect,
    pub pixels_per_point: f32,
    pub time: f64,
    pub unstable_dt: f32,
    pub predicted_dt: f32,
    pub modifiers: Modifiers,
    pub keys_down: HashSet<Key>,
    pub events: Vec<Event>,
    // some fields omitted
}

Expand description

Input state that egui updates each frame.

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.

scroll_delta: Vec2

How many pixels the user scrolled.

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.

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) so it can be smart to use e.g. unstable_dt.min(1.0 / 30.0).

predicted_dt: f32

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

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

[src]

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

[src]

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

[src]

pub fn wants_repaint(&self) -> bool

[src]

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

Was the given key pressed this frame?

[src]

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

How many times were the given key pressed this frame?

[src]

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

Is the given key currently held down?

[src]

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

Was the given key released this frame?

[src]

pub fn pixels_per_point(&self) -> f32

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

[src]

pub fn physical_pixel_size(&self) -> f32

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

[src]

pub fn aim_radius(&self) -> f32

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

[src]

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
if let Some(multi_touch) = ui.input().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. egui_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.

[src]