Struct ReposeRuntime 

pub struct ReposeRuntime {

    pub sched: Scheduler,
    pub scale: f32,
    pub modifiers: Modifiers,
    pub mouse_pos_px: (f32, f32),
    pub pointer_inside: bool,
    pub hover_id: Option<u64>,
    pub hover_ancestors: HashSet<u64>,
    pub capture_id: Option<u64>,
    pub hit_path: Option<Vec<u64>>,
    pub scroll_capture_id: Option<u64>,
    pub pressed_ids: HashSet<u64>,
    pub ime_preedit: bool,
    pub key_pressed_active: Option<u64>,
    pub last_focus: Option<u64>,
    pub frame_cache: Option<Frame>,
    pub textfield_states: HashMap<u64, Rc<RefCell<TextFieldState>>>,
    pub gamepads: HashMap<u32, GamepadPad>,
    pub pending_rumble: Vec<(u32, f32, f32, u32)>,
    /* private fields */
}

Embeddable Repose runtime.

Manages composition scheduling, input routing, text-field state, and pointer/key dispatch. The host owns the event loop and GPU device. This is purely the UI logic layer.

Fields

sched: Scheduler

scale: f32

modifiers: Modifiers

mouse_pos_px: (f32, f32)

pointer_inside: bool

Whether the pointer is currently inside the window.

hover_id: Option<u64>

hover_ancestors: HashSet<u64>

capture_id: Option<u64>

hit_path: Option<Vec<u64>>

Hit path captured at pointer-down: every region under the pointer, ordered bottom-up (deepest child first, ancestors last).

scroll_capture_id: Option<u64>

Which scroll consumer currently owns the wheel gesture.

pressed_ids: HashSet<u64>

ime_preedit: bool

key_pressed_active: Option<u64>

last_focus: Option<u64>

frame_cache: Option<Frame>

textfield_states: HashMap<u64, Rc<RefCell<TextFieldState>>>

gamepads: HashMap<u32, GamepadPad>

Connected gamepads by backend id: display name plus live button/axis state. Fed by ReposeRuntime::handle_gamepad.

pending_rumble: Vec<(u32, f32, f32, u32)>

Queued dual-motor rumble requests.

Implementations

impl ReposeRuntime

pub fn new() -> Self

pub fn set_viewport(&mut self, width_px: u32, height_px: u32)

Set the logical viewport size (in device pixels).

pub fn set_viewport_and_scale( &mut self, width_px: u32, height_px: u32, scale: f32, )

Set viewport size and DPI scale factor.

pub fn tick_animations(&self)

Advance animations. Call before compose each frame.

pub fn poll_gesture_timers(&mut self)

pub fn compose<F>( &mut self, root_fn: &mut F, render_ctx: &RenderContext, ) -> Frame

where F: FnMut(&mut Scheduler, &RenderContext) -> View,

Compose and layout a frame, returning the output for rendering.

Call tick_animations before this and cache_frame after (once you have applied any host-specific overlays like the devtools inspector).

pub fn frame( &mut self, root_fn: impl FnMut(&mut Scheduler, &RenderContext) -> View, render_ctx: &RenderContext, ) -> FrameOutput

Compose a frame and return structured output for the host.

pub fn cache_frame(&mut self, frame: Frame)

Store the composed frame for event hit testing.

pub fn after_compose(&mut self, frame: &Frame, scale: f32)

Post-compose host-agnostic bookkeeping. this lazy-initializes text-field state for focus-requester paths, reconciles hover against the new hit list, and publishes the frame to the DnD registry. Replaces platform-local copies of this logic.

pub fn ensure_focused_textfield_state(&mut self)

Lazy-init the focused textfield’s persistent state (FocusRequester paths don’t create it until first click). Resets the caret blink.

pub fn cache_from_output(&mut self, out: &FrameOutput)

Cache a composed FrameOutput for hit-testing: rebuilds the retained hover-leave map, reconciles hover, lazy-initializes focused textfield state, and publishes the DnD frame/scale to the input registry.

pub fn compose_frame_output<F>( &mut self, root: &mut F, render_ctx: &RenderContext, ) -> FrameOutput

where F: FnMut(&mut Scheduler, &RenderContext) -> View,

One-shot host tick: advance animations, compose a frame, and publish the result (hover reconciliation, focused textfield lazy-init, DnD frame/scale) in a single call.

pub fn handle_pointer_move(&mut self, pos: Vec2) -> PointerMoveResult

Process a pointer-move event. Returns cursor suggestion.

pub fn handle_pointer_press( &mut self, pos: Vec2, button: PointerButton, ) -> PointerButtonResult

Process a pointer button press. Returns focus/capture info.

pub fn handle_pointer_release( &mut self, pos: Vec2, button: PointerButton, ) -> PointerButtonResult

Process a pointer button release.

pub fn handle_pointer_cancel(&mut self)

Cancel pointer state (focus lost, cursor left window, etc.).

pub fn clear_hover(&mut self)

Clear hover state, emitting HoverLeave for the currently hovered region.

pub fn reconcile_hover_from_mouse_pos(&mut self, new_frame: &Frame)

Reconcile hover state when the composed frame changes.

pub fn handle_scroll(&mut self, delta: Vec2) -> bool

Process a scroll event. Returns true if consumed.

pub fn handle_key(&mut self, event: &KeyEvent) -> bool

Process a keyboard key event. Returns true if consumed.

pub fn dispatch_action(&mut self, action: Action) -> bool

Dispatch a shortcut action: widget handler first, then built-in textfield editing, then the global shortcut map, then focus navigation. Returns true if the action was consumed.

pub fn handle_ime(&mut self, event: &ImeEvent)

Process an IME event.

pub fn handle_focus_lost(&mut self)

Handle focus lost (window unfocused, etc.).

pub fn ensure_textfield_state( &mut self, key: u64, ) -> Rc<RefCell<TextFieldState>>

Get or create a text field state by its key.

pub fn ensure_textfield_state_seeded( &mut self, key: u64, seed: &str, ) -> Rc<RefCell<TextFieldState>>

pub fn tf_key_of(&self, visual_id: u64) -> u64

Look up the persistent state key for a visual hit-region id.

pub fn is_textfield(&self, id: u64) -> bool

True if the given id belongs to a TextField.

pub fn is_multiline(&self, id: u64) -> bool

True if the given textfield id is multiline.

pub fn focused_keyboard_hints( &self, ) -> (ImePurposeHint, bool, KeyboardCapitalization)

Keyboard hints of the currently focused text field, or defaults if none. Returns (purpose, auto_correct, capitalization) for the platform runner.

pub fn insert_text_into_focused(&mut self, text: &str) -> bool

Insert arbitrary text into the focused text field (composed keyboard text, clipboard paste, hardware-keyboard fallback, …). Returns true if text was inserted.

Control chars are filtered. Newlines are dropped for single-line fields. Skipped during IME preedit.

pub fn insert_text(&mut self, text: &str) -> bool

Insert plain text into the focused textfield (winit key_event.text, Android soft-keyboard text, web paste). Alias for Self::insert_text_into_focused.

pub fn paste_into_focused(&mut self, text: &str)

Insert text into a focused text field (used for paste). Uses an atomic (non-mergeable) edit so Ctrl+V doesn’t merge with adjacent typing.

pub fn handle_gamepad(&mut self, event: &GamepadEvent) -> bool

Process a gamepad event: mirror connection/button/axis state into ReposeRuntime::gamepads. Sticks, shoulders and face extras stay raw gameplay input for the game to read from ReposeRuntime::gamepads.

Returns true when the event drove UI navigation.

pub fn request_rumble( &mut self, id: GamepadId, low_freq: f32, high_freq: f32, duration_ms: u32, )

Queue a dual-motor rumble for id (SDL-style: low = strong motor, high = weak motor, 0.0..=1.0, duration_ms). The platform runner drains the queue each frame into GamepadBackend::set_rumble. A duration_ms of 0 stops. No-op when the pad is unknown.

pub fn stop_rumble(&mut self, id: GamepadId)

Queue a rumble stop for id.

pub fn take_rumble_requests(&mut self) -> Vec<(u32, f32, f32, u32)>

Drain queued rumble requests (platform runners call this after poll).

pub fn handle_key_with_text( &mut self, event: &KeyEvent, composed_text: Option<&str>, ) -> bool

Process a key event with an optional host-composed text payload (winit key_event.text, Android soft-keyboard text, …).

When the modifiers are free of Ctrl/Alt/Meta and the payload is Printable text goes to the focused field first. Otherwise falls through to handle_key.

pub fn handle_scroll_at( &mut self, pos: Vec2, delta: Vec2, scroll_capture: Option<u64>, ) -> (bool, Option<u64>)

Process a scroll event at an explicit position, honoring a caller-owned scroll capture id (touch gestures initialize the capture themselves). Returns (consumed, updated_capture_id).

pub fn next_wakeup_deadline(&self) -> Option<Instant>

Centralized wakeup helper for platform runners (caret, snackbar, timers, etc.). Debounced entries live on the shared timer queue, so timer covers them.

pub fn is_wakeup_due(&self, now: Instant) -> bool

Whether a scheduled wakeup is due at now (deadline <= now).

pub fn is_caret_blink_due(&self, now: Instant) -> bool

Whether a caret blink edge is due at now (deadline <= now). Deprecated: use is_wakeup_due.

pub fn next_frame_deadline(&self, now: Instant, idle_cap: Duration) -> Instant

Desktop-style deadline with idle keep-alive fallback. idle_cap is the maximum time the host should sleep without a scheduled wakeup (e.g. 1s on desktop to handle tray Deeplinks).

pub fn tick_overlays(&self)

Tick host-facing overlays (snackbar timeouts) and timers (including debounced entries, which live on the shared timer queue). Call once per redraw.

pub fn cursor_suggestion(&self) -> Option<CursorIcon>

Get the cursor suggestion (set during pointer-move handling).

pub fn take_cursor_suggestion(&mut self) -> Option<CursorIcon>

Take the cursor suggestion (clears it).

Trait Implementations

impl Default for ReposeRuntime

fn default() -> Self

Returns the “default value” for a type.