Struct View 

pub struct View<Rend: WindowRenderer> {

    pub doc: Box<dyn Document>,
    pub renderer: Rend,
    pub waker: Option<Waker>,
    pub proxy: BlitzShellProxy,
    pub window: Arc<dyn Window>,
    pub theme_override: Option<Theme>,
    pub keyboard_modifiers: Modifiers,
    pub buttons: MouseEventButtons,
    pub pointer_pos: PhysicalPosition<f64>,
    pub active_events: Arc<AtomicRefCell<Vec<BlitzPointerEvent>>>,
    pub animation_timer: Option<Instant>,
    pub is_visible: bool,
    pub safe_area_insets: PhysicalInsets<u32>,
    pub accessibility: AccessibilityState,
    pub animation_frame_due: Cell<Option<Instant>>,
    /* private fields */
}

Fields

doc: Box<dyn Document>

renderer: Rend

waker: Option<Waker>

proxy: BlitzShellProxy

window: Arc<dyn Window>

theme_override: Option<Theme>

The state of the keyboard modifiers (ctrl, shift, etc). Winit/Tao don’t track these for us so we need to store them in order to have access to them when processing keypress events

keyboard_modifiers: Modifiers

buttons: MouseEventButtons

pointer_pos: PhysicalPosition<f64>

active_events: Arc<AtomicRefCell<Vec<BlitzPointerEvent>>>

The non-mouse pointers (touch/pen) that are currently pressed, in the order they were pressed.

This serves two purposes:

• Multi-touch: it is cloned (cheaply, via Arc) into every dispatched BlitzPointerEvent so that touch events can report all concurrent touches via their touches list.
• Cancellation detection: winit signals a cancelled touch with a WindowEvent::PointerLeft that is not preceded by a WindowEvent::PointerButton with ElementState::Released. If a pointer is still in this list when it leaves, it was cancelled.

The events stored here always have an empty active_pointers list to avoid a reference cycle.

animation_timer: Option<Instant>

is_visible: bool

safe_area_insets: PhysicalInsets<u32>

accessibility: AccessibilityState

Available on crate feature accessibility only.

Accessibility adapter for accesskit.

animation_frame_due: Cell<Option<Instant>>

When the next animation-only frame is due, if one is.

An animation drives frames by asking for the next redraw at the end of the last one, which runs it at the display’s rate. Set this instead of asking immediately, and about_to_wait turns it into a ControlFlow::WaitUntil, so the loop sleeps in between rather than spinning. None means nothing is animating and the loop can wait indefinitely for input.

Implementations

impl<Rend: WindowRenderer> View<Rend>

pub fn init( config: WindowConfig<Rend>, event_loop: &dyn ActiveEventLoop, proxy: &BlitzShellProxy, ) -> Self

pub fn replace_document( &mut self, new_doc: Box<dyn Document>, retain_scroll_position: bool, )

pub fn theme_override(&self) -> Option<Theme>

pub fn current_theme(&self) -> Theme

pub fn set_theme_override(&mut self, theme: Option<Theme>)

pub fn downcast_doc_mut<T: 'static>(&mut self) -> &mut T

pub fn try_downcast_doc_mut<T: 'static>(&mut self) -> Option<&mut T>

pub fn current_animation_time(&mut self) -> f64

impl<Rend: WindowRenderer> View<Rend>

pub fn resume(&mut self)

Start resuming the renderer. Dispatches BlitzShellEvent::ResumeReady when initialization completes — synchronously on native, asynchronously on wasm32. The embedder must call complete_resume in response.

pub fn complete_resume(&mut self) -> bool

Finalize a previously-started resume. Should be called in response to a BlitzShellEvent::ResumeReady event. Paints the first frame and installs the doc poll waker. Returns true if the renderer is now active.

pub fn suspend(&mut self)

pub fn request_poll(&self)

Ask for a poll before the event loop next sleeps.

Costs one relaxed store when the flag is already set, which is the common case during a drag or a scroll.

pub fn poll_if_requested(&mut self) -> bool

Poll iff a poll was asked for since the last drain, clearing the request.

pub fn poll(&mut self) -> bool

pub fn request_redraw(&self)

pub fn redraw(&mut self)

pub fn poll_animation_frame(&self, now: Instant) -> Option<Instant>

Ask for the pending animation frame if it is due, and report when the next one falls due so the event loop can sleep until then.

Returns None when nothing is animating, which lets the loop wait for input instead of on a clock.

pub fn pointer_coords(&self, position: PhysicalPosition<f64>) -> PointerCoords

pub fn window_id(&self) -> WindowId

pub fn with_viewport(&mut self, cb: impl FnOnce(&mut Viewport))

pub fn build_accessibility_tree(&mut self)

Available on crate feature accessibility only.

pub fn handle_winit_event(&mut self, event: WindowEvent)

Trait Implementations

impl<Rend: WindowRenderer> Drop for View<Rend>

fn drop(&mut self)

Executes the destructor for this type.

fn pin_drop(self: Pin<&mut Self>)

🔬This is a nightly-only experimental API. (pin_ergonomics)

Execute the destructor for this type, but different to Drop::drop, it requires self to be pinned.