Struct egui_winit::State

pub struct State {
    pub(crate) start_time: Instant,
    pub(crate) egui_input: RawInput,
    pub(crate) pointer_pos_in_points: Option<Pos2>,
    pub(crate) any_pointer_button_down: bool,
    pub(crate) current_cursor_icon: Option<CursorIcon>,
    pub(crate) current_pixels_per_point: f32,
    pub(crate) clipboard: Clipboard,
    pub(crate) simulate_touch_screen: bool,
    pub(crate) pointer_touch_id: Option<u64>,
    pub(crate) input_method_editor_started: bool,
}

Handles the integration between egui and winit.

Fields

start_time: Instant

egui_input: RawInput

pointer_pos_in_points: Option<Pos2>

any_pointer_button_down: bool

current_cursor_icon: Option<CursorIcon>

current_pixels_per_point: f32

What egui uses.

clipboard: Clipboard

simulate_touch_screen: bool

If true, mouse inputs will be treated as touches. Useful for debugging touch support in egui.

Creates duplicate touches, if real touch inputs are coming.

pointer_touch_id: Option<u64>

Is Some(…) when a touch is being translated to a pointer.

Only one touch will be interpreted as pointer at any time.

input_method_editor_started: bool

track ime state

Implementations

impl State

pub fn new(display_target: &dyn HasRawDisplayHandle) -> Self

Construct a new instance

Safety

The returned State must not outlive the input display_target.

pub fn set_max_texture_side(&mut self, max_texture_side: usize)

Call this once a graphics context has been created to update the maximum texture dimensions that egui will use.

pub fn set_pixels_per_point(&mut self, pixels_per_point: f32)

Call this when a new native Window is created for rendering to initialize the pixels_per_point for that window.

In particular, on Android it is necessary to call this after each Resumed lifecycle event, each time a new native window is created.

Once this has been initialized for a new window then this state will be maintained by handling winit::event::WindowEvent::ScaleFactorChanged events.

pub fn pixels_per_point(&self) -> f32

The number of physical pixels per logical point, as configured on the current egui context (see egui::Context::pixels_per_point).

pub fn egui_input(&self) -> &RawInput

The current input state. This is changed by Self::on_event and cleared by Self::take_egui_input.

pub fn take_egui_input(&mut self, window: &Window) -> RawInput

Prepare for a new frame by extracting the accumulated input, as well as setting the time and screen rectangle.

pub fn on_event(
    &mut self,
    egui_ctx: &Context,
    event: &WindowEvent<'_>
) -> EventResponse

Call this when there is a new event.

The result can be found in Self::egui_input and be extracted with Self::take_egui_input.

pub(crate) fn on_mouse_button_input(
    &mut self,
    state: ElementState,
    button: MouseButton
)

pub(crate) fn on_cursor_moved(&mut self, pos_in_pixels: PhysicalPosition<f64>)

pub(crate) fn on_touch(&mut self, touch: &Touch)

pub(crate) fn on_mouse_wheel(&mut self, delta: MouseScrollDelta)

pub(crate) fn on_keyboard_input(&mut self, input: &KeyboardInput)

pub fn handle_platform_output(
    &mut self,
    window: &Window,
    egui_ctx: &Context,
    platform_output: PlatformOutput
)

Call with the output given by egui.

This will, if needed:

• update the cursor
• copy text to the clipboard
• open any clicked urls
• update the IME

pub(crate) fn set_cursor_icon(&mut self, window: &Window, cursor_icon: CursorIcon)