Struct egui::input_state::InputState
source · pub struct InputState {Show 20 fields
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>,
}
Expand description
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 togetherzoom > 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
Implementations§
source§impl InputState
impl InputState
pub fn begin_frame( self, new: RawInput, requested_immediate_repaint_prev_frame: bool, pixels_per_point: f32, options: &Options, ) -> Self
sourcepub fn viewport(&self) -> &ViewportInfo
pub fn viewport(&self) -> &ViewportInfo
Info about the active viewport
pub fn screen_rect(&self) -> Rect
sourcepub fn zoom_delta(&self) -> f32
pub fn zoom_delta(&self) -> f32
Zoom scale factor this frame (e.g. from ctrl-scroll or pinch gesture).
zoom = 1
: no changezoom < 1
: pinch togetherzoom > 1
: pinch spread
sourcepub fn zoom_delta_2d(&self) -> Vec2
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 changezoom < 1
: pinch togetherzoom > 1
: pinch spread
sourcepub fn time_since_last_scroll(&self) -> f32
pub fn time_since_last_scroll(&self) -> f32
How long has it been (in seconds) since the use last scrolled?
sourcepub fn wants_repaint_after(&self) -> Option<Duration>
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.
sourcepub fn count_and_consume_key(
&mut self,
modifiers: Modifiers,
logical_key: Key,
) -> usize
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!
sourcepub fn consume_key(&mut self, modifiers: Modifiers, logical_key: Key) -> bool
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!
sourcepub fn consume_shortcut(&mut self, shortcut: &KeyboardShortcut) -> bool
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!
sourcepub fn key_pressed(&self, desired_key: Key) -> bool
pub fn key_pressed(&self, desired_key: Key) -> bool
Was the given key pressed this frame?
Includes key-repeat events.
sourcepub fn num_presses(&self, desired_key: Key) -> usize
pub fn num_presses(&self, desired_key: Key) -> usize
How many times was the given key pressed this frame?
Includes key-repeat events.
sourcepub fn key_released(&self, desired_key: Key) -> bool
pub fn key_released(&self, desired_key: Key) -> bool
Was the given key released this frame?
sourcepub fn pixels_per_point(&self) -> f32
pub fn pixels_per_point(&self) -> f32
Also known as device pixel ratio, > 1 for high resolution screens.
sourcepub fn physical_pixel_size(&self) -> f32
pub fn physical_pixel_size(&self) -> f32
Size of a physical pixel in logical gui coordinates (points).
sourcepub fn aim_radius(&self) -> f32
pub fn aim_radius(&self) -> f32
How imprecise do we expect the mouse/touch input to be? Returns imprecision in points.
sourcepub fn multi_touch(&self) -> Option<MultiTouchInfo>
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.
sourcepub fn any_touches(&self) -> bool
pub fn any_touches(&self) -> bool
True if there currently are any fingers touching egui.
sourcepub fn has_touch_screen(&self) -> bool
pub fn has_touch_screen(&self) -> bool
True if we have ever received a touch event.
sourcefn create_touch_states_for_new_devices(&mut self, events: &[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.
sourcepub fn filtered_events(&self, filter: &EventFilter) -> Vec<Event>
pub fn filtered_events(&self, filter: &EventFilter) -> Vec<Event>
Get all events that matches the given filter.
sourcepub(crate) fn is_long_touch(&self) -> bool
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.
Trait Implementations§
source§impl Clone for InputState
impl Clone for InputState
source§fn clone(&self) -> InputState
fn clone(&self) -> InputState
1.0.0 · source§fn clone_from(&mut self, source: &Self)
fn clone_from(&mut self, source: &Self)
source
. Read more