Skip to main content

sui_platform/
desktop.rs

1use std::{
2    cell::Cell,
3    collections::HashMap,
4    fmt,
5    sync::{
6        Arc,
7        atomic::{AtomicBool, Ordering},
8    },
9    time::Duration,
10};
11
12use sui_core::{
13    CursorGrabMode, Error, Event, ImeEvent, KeyState, KeyboardEvent, Modifiers, Point,
14    PointerButton, PointerButtons, PointerEvent, PointerEventKind, PointerKind,
15    RawMouseMotionEvent, Result, ScrollDelta, SemanticsRole, Size, Vector, WindowEvent, WindowId,
16};
17use sui_render_wgpu::{MemoryTrimLevel, WgpuExternalTextureRegistry, WgpuRenderer};
18use sui_runtime::{
19    CommandSender, FramePacing, PresentationLatencyDiagnostics, Runtime,
20    WindowIcon as RuntimeWindowIcon, WindowPerformanceSnapshot, window_performance_snapshot,
21};
22use web_time::Instant;
23use winit::{
24    application::ApplicationHandler,
25    dpi::{LogicalPosition, LogicalSize, PhysicalPosition, PhysicalSize},
26    error::{EventLoopError, OsError},
27    event::{
28        DeviceEvent, DeviceId, ElementState, Ime, MouseButton, MouseScrollDelta, TouchPhase,
29        WindowEvent as WinitWindowEvent,
30    },
31    event_loop::{ActiveEventLoop, ControlFlow, EventLoop, EventLoopProxy},
32    keyboard::{Key, ModifiersState, NamedKey, PhysicalKey},
33    window::{
34        CursorGrabMode as WinitCursorGrabMode, Window, WindowAttributes, WindowId as HostWindowId,
35    },
36};
37
38#[cfg(not(target_arch = "wasm32"))]
39use winit::monitor::MonitorHandle;
40
41#[cfg(target_os = "windows")]
42use accesskit_winit::{
43    Adapter as AccessKitAdapter, Event as AccessKitEvent, WindowEvent as AccessKitWindowEvent,
44};
45
46#[cfg(target_os = "windows")]
47use std::collections::HashSet;
48
49#[cfg(not(target_arch = "wasm32"))]
50use winit::window::Icon as WinitIcon;
51
52#[cfg(not(target_arch = "wasm32"))]
53const DEFAULT_WINDOW_ICON_SIZE: u32 = 256;
54
55#[cfg(target_arch = "wasm32")]
56use winit::platform::web::{EventLoopExtWebSys, WindowAttributesExtWebSys, WindowExtWebSys};
57
58#[cfg(target_arch = "wasm32")]
59use wasm_bindgen::JsCast;
60
61#[cfg(target_os = "android")]
62use winit::platform::android::EventLoopBuilderExtAndroid;
63#[cfg(target_os = "android")]
64pub use winit::platform::android::activity::AndroidApp;
65
66#[cfg(target_arch = "wasm32")]
67const WEB_LEGACY_FAVICON_ID: &str = "sui-window-icon";
68#[cfg(target_arch = "wasm32")]
69const WEB_SVG_FAVICON_ID: &str = "sui-window-icon-svg";
70#[cfg(target_arch = "wasm32")]
71const WEB_PNG_FAVICON_ID: &str = "sui-window-icon-png";
72#[cfg(target_arch = "wasm32")]
73const WEB_APPLE_TOUCH_ICON_ID: &str = "sui-window-apple-touch-icon";
74
75use crate::frame_pacing::FrameCadence;
76use crate::{
77    AccessibilityBridge, PresentedFrame, detect_window_display_capabilities,
78    headless::PlatformWindow, present_window_frame,
79};
80
81#[cfg(target_os = "windows")]
82use crate::windows_accessibility::{AccessKitSnapshot, build_accesskit_snapshot};
83
84#[derive(Debug)]
85enum DesktopUserEvent {
86    ExternalWake(WakeSignal),
87    ReactiveWake(WakeSignal),
88    #[cfg(target_os = "windows")]
89    AccessKit(AccessKitEvent),
90}
91
92#[derive(Debug, Default, Clone, Copy, PartialEq, Eq)]
93enum HostLifecycle {
94    #[default]
95    AwaitingResume,
96    Resumed,
97    Suspended,
98}
99
100/// Optional integration driven alongside SUI's desktop event loop.
101///
102/// Extensions are updated on the UI thread after runtime work and window
103/// synchronization. They are intended for native child surfaces and other
104/// platform-owned objects that must follow SUI window and widget lifecycles
105/// without becoming dependencies of the renderer-neutral runtime.
106pub trait DesktopExtension: fmt::Debug {
107    /// Synchronize extension state with the current runtime and native windows.
108    fn update(&mut self, _context: DesktopExtensionContext<'_>) -> Result<()> {
109        Ok(())
110    }
111
112    /// Observe a successfully submitted content frame. The timestamp is captured
113    /// immediately after the renderer returns from presentation, before diagnostics
114    /// or extension work. This is not a physical scanout timestamp.
115    fn frame_presented(
116        &mut self,
117        _context: DesktopExtensionContext<'_>,
118        _frame: DesktopFramePresented,
119    ) -> Result<()> {
120        Ok(())
121    }
122
123    /// Release or suspend native resources before the host surfaces suspend.
124    fn suspended(&mut self) -> Result<()> {
125        Ok(())
126    }
127
128    /// Request a maximum idle interval while the extension has work that must
129    /// be pumped even when SUI itself has no scheduled wakeup.
130    fn poll_interval(&self) -> Option<Duration> {
131        None
132    }
133}
134
135#[derive(Debug, Clone, Copy)]
136pub struct DesktopFramePresented {
137    pub window_id: WindowId,
138    pub frame_index: u64,
139    pub presented_at: Instant,
140    pub runtime_duration: Duration,
141}
142
143/// Read-only state supplied to a [`DesktopExtension`] update.
144pub struct DesktopExtensionContext<'a> {
145    runtime: &'a Runtime,
146    renderer: &'a WgpuRenderer,
147    windows: &'a HashMap<WindowId, WindowState>,
148    commands: &'a CommandSender,
149}
150
151impl<'a> DesktopExtensionContext<'a> {
152    /// Borrow the retained runtime for widget graph and lifecycle snapshots.
153    pub const fn runtime(&self) -> &'a Runtime {
154        self.runtime
155    }
156
157    /// Inspect renderer state and adapter metadata without enabling GPU interop.
158    pub const fn renderer(&self) -> &'a WgpuRenderer {
159        self.renderer
160    }
161
162    /// Borrow the command sender associated with the running application.
163    pub const fn command_sender(&self) -> &'a CommandSender {
164        self.commands
165    }
166
167    /// Look up one live native window by its SUI identifier.
168    pub fn window(&self, window_id: WindowId) -> Option<DesktopWindow<'a>> {
169        self.windows.get(&window_id).map(DesktopWindow::from_state)
170    }
171}
172
173impl fmt::Debug for DesktopExtensionContext<'_> {
174    fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
175        formatter
176            .debug_struct("DesktopExtensionContext")
177            .field("window_count", &self.windows.len())
178            .finish_non_exhaustive()
179    }
180}
181
182/// A live `winit` window exposed to a desktop extension.
183#[derive(Clone, Copy)]
184pub struct DesktopWindow<'a> {
185    id: WindowId,
186    window: &'a Window,
187}
188
189impl<'a> DesktopWindow<'a> {
190    fn from_state(state: &'a WindowState) -> Self {
191        Self {
192            id: state.id,
193            window: state.window.as_ref(),
194        }
195    }
196
197    /// Return the SUI window identifier.
198    pub const fn id(self) -> WindowId {
199        self.id
200    }
201
202    /// Borrow the native `winit` window.
203    pub const fn host_window(self) -> &'a Window {
204        self.window
205    }
206}
207
208impl fmt::Debug for DesktopWindow<'_> {
209    fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
210        formatter
211            .debug_struct("DesktopWindow")
212            .field("id", &self.id)
213            .field("host_id", &self.window.id())
214            .finish()
215    }
216}
217
218impl HostLifecycle {
219    fn is_resumed(self) -> bool {
220        self == Self::Resumed
221    }
222
223    /// Returns `true` when host surfaces need to be created or restored.
224    fn resume(&mut self) -> bool {
225        if self.is_resumed() {
226            return false;
227        }
228        *self = Self::Resumed;
229        true
230    }
231
232    /// Returns `true` when live host surfaces need to be released.
233    fn suspend(&mut self) -> bool {
234        let had_surfaces = self.is_resumed();
235        *self = Self::Suspended;
236        had_surfaces
237    }
238}
239
240#[cfg(target_os = "windows")]
241impl From<AccessKitEvent> for DesktopUserEvent {
242    fn from(event: AccessKitEvent) -> Self {
243        Self::AccessKit(event)
244    }
245}
246
247#[derive(Debug, Default)]
248pub struct DesktopPlatform {
249    renderer: WgpuRenderer,
250    automation: Option<DesktopAutomationConfig>,
251    extensions: Vec<Box<dyn DesktopExtension>>,
252    #[cfg(target_arch = "wasm32")]
253    web_canvas: Option<web_sys::HtmlCanvasElement>,
254}
255
256#[derive(Debug, Clone, PartialEq)]
257pub enum DesktopAutomationAction {
258    ScrollPixels { delta: Vector },
259}
260
261#[derive(Debug, Clone, PartialEq)]
262pub struct DesktopAutomationConfig {
263    pub label: String,
264    pub target_role: SemanticsRole,
265    pub target_name: String,
266    pub action: DesktopAutomationAction,
267    pub step_interval: Duration,
268    pub duration: Duration,
269    pub report_interval: Duration,
270    pub startup_timeout: Duration,
271}
272
273#[derive(Debug, Clone)]
274struct DesktopAutomationState {
275    config: DesktopAutomationConfig,
276    armed_at: Instant,
277    started_at: Option<Instant>,
278    next_step_at: Instant,
279    last_report_at: Option<Instant>,
280    last_report_frame_index: u64,
281    target_window_id: Option<WindowId>,
282    pointer_primed: bool,
283    shutdown_requested: bool,
284}
285
286impl DesktopAutomationState {
287    fn new(config: DesktopAutomationConfig) -> Self {
288        let now = Instant::now();
289        Self {
290            config,
291            armed_at: now,
292            started_at: None,
293            next_step_at: now,
294            last_report_at: None,
295            last_report_frame_index: 0,
296            target_window_id: None,
297            pointer_primed: false,
298            shutdown_requested: false,
299        }
300    }
301
302    fn next_deadline(&self) -> Option<Instant> {
303        if self.shutdown_requested {
304            return None;
305        }
306
307        let mut next = self.next_step_at;
308        if let Some(started_at) = self.started_at {
309            next = next.min(started_at + self.config.duration);
310            if let Some(last_report_at) = self.last_report_at {
311                next = next.min(last_report_at + self.config.report_interval);
312            }
313        } else {
314            next = next.min(self.armed_at + self.config.startup_timeout);
315        }
316
317        Some(next)
318    }
319}
320
321impl DesktopPlatform {
322    const DEFAULT_WINDOW_SIZE: Size = Size::new(1280.0, 720.0);
323
324    pub fn new() -> Self {
325        crate::reset_window_performance_store();
326        Self::default()
327    }
328
329    pub fn with_feather_width(mut self, feather_width: f32) -> Self {
330        self.set_feather_width(feather_width);
331        self
332    }
333
334    pub fn with_feathering_enabled(mut self, enabled: bool) -> Self {
335        self.set_feathering_enabled(enabled);
336        self
337    }
338
339    /// Enable synchronized presentation. Focused, drawable windows continue
340    /// presenting retained content so variable-refresh displays stay responsive.
341    pub fn with_vsync_enabled(mut self, enabled: bool) -> Self {
342        self.set_vsync_enabled(enabled);
343        self
344    }
345
346    pub fn with_external_texture_registry(mut self, registry: WgpuExternalTextureRegistry) -> Self {
347        self.set_external_texture_registry(registry);
348        self
349    }
350
351    pub fn with_automation(mut self, automation: DesktopAutomationConfig) -> Self {
352        self.automation = Some(automation);
353        self
354    }
355
356    /// Draw the first window on `canvas` instead of the page's element with id
357    /// `sui-main-canvas`.
358    #[cfg(target_arch = "wasm32")]
359    pub fn with_web_canvas(mut self, canvas: web_sys::HtmlCanvasElement) -> Self {
360        self.web_canvas = Some(canvas);
361        self
362    }
363
364    /// Attach an optional UI-thread desktop integration.
365    pub fn with_extension(mut self, extension: impl DesktopExtension + 'static) -> Self {
366        self.extensions.push(Box::new(extension));
367        self
368    }
369
370    pub fn renderer(&self) -> &WgpuRenderer {
371        &self.renderer
372    }
373
374    pub fn feather_width(&self) -> f32 {
375        self.renderer.feather_width()
376    }
377
378    pub fn feathering_enabled(&self) -> bool {
379        self.renderer.feathering_enabled()
380    }
381
382    pub fn vsync_enabled(&self) -> bool {
383        self.renderer.vsync_enabled()
384    }
385
386    pub fn set_feather_width(&mut self, feather_width: f32) {
387        self.renderer.set_feather_width(feather_width);
388    }
389
390    pub fn set_feathering_enabled(&mut self, enabled: bool) {
391        self.renderer.set_feathering_enabled(enabled);
392    }
393
394    pub fn set_vsync_enabled(&mut self, enabled: bool) {
395        self.renderer.set_vsync_enabled(enabled);
396    }
397
398    pub fn set_external_texture_registry(&mut self, registry: WgpuExternalTextureRegistry) {
399        self.renderer.set_external_texture_registry(registry);
400    }
401
402    pub fn renderer_mut(&mut self) -> &mut WgpuRenderer {
403        &mut self.renderer
404    }
405
406    pub fn run(self, runtime: Runtime) -> Result<Vec<PlatformWindow>> {
407        self.run_with(runtime, |_| {})
408    }
409
410    #[cfg(target_os = "android")]
411    pub fn run_android(
412        self,
413        runtime: Runtime,
414        android_app: AndroidApp,
415    ) -> Result<Vec<PlatformWindow>> {
416        self.run_android_with(runtime, android_app, |_| {})
417    }
418
419    /// Like [`run`](Self::run) but hands the caller a typed, thread-safe
420    /// [`CommandSender`] before the loop starts.
421    pub fn run_with(
422        self,
423        mut runtime: Runtime,
424        on_ready: impl FnOnce(CommandSender),
425    ) -> Result<Vec<PlatformWindow>> {
426        let (event_loop, event_loop_proxy, external_wake_pending, reactive_wake_pending) =
427            create_event_loop(&mut runtime, on_ready)?;
428
429        #[cfg(target_arch = "wasm32")]
430        {
431            self.spawn_web(
432                event_loop,
433                runtime,
434                event_loop_proxy,
435                external_wake_pending,
436                reactive_wake_pending,
437                |result| {
438                    if let Err(error) = result {
439                        web_sys::console::error_1(&wasm_bindgen::JsValue::from_str(
440                            &error.to_string(),
441                        ));
442                    }
443                },
444            );
445            Ok(Vec::new())
446        }
447
448        #[cfg(not(target_arch = "wasm32"))]
449        {
450            let mut app = DesktopApp::new(
451                runtime,
452                self.renderer,
453                self.automation,
454                self.extensions,
455                event_loop_proxy,
456                external_wake_pending,
457                reactive_wake_pending,
458            );
459            event_loop.run_app(&mut app).map_err(map_event_loop_error)?;
460
461            if let Some(error) = app.last_error.take() {
462                return Err(error);
463            }
464
465            Ok(app.snapshot_windows())
466        }
467    }
468
469    /// Start the application in the browser. The browser's event loop drives
470    /// it; this returns once the app is scheduled, and `on_exit` runs when
471    /// the app exits, with the error it stopped with, if any.
472    ///
473    /// Only one app can run per page.
474    #[cfg(target_arch = "wasm32")]
475    pub fn start_web(
476        self,
477        mut runtime: Runtime,
478        on_ready: impl FnOnce(CommandSender),
479        on_exit: impl FnOnce(Result<()>) + 'static,
480    ) -> Result<()> {
481        let (event_loop, event_loop_proxy, external_wake_pending, reactive_wake_pending) =
482            create_event_loop(&mut runtime, on_ready)?;
483        self.spawn_web(
484            event_loop,
485            runtime,
486            event_loop_proxy,
487            external_wake_pending,
488            reactive_wake_pending,
489            on_exit,
490        );
491        Ok(())
492    }
493
494    /// Initialize the renderer, then hand the app to the browser's event
495    /// loop.
496    #[cfg(target_arch = "wasm32")]
497    fn spawn_web(
498        self,
499        event_loop: EventLoop<DesktopUserEvent>,
500        runtime: Runtime,
501        event_loop_proxy: EventLoopProxy<DesktopUserEvent>,
502        external_wake_pending: Arc<AtomicBool>,
503        reactive_wake_pending: Arc<AtomicBool>,
504        on_exit: impl FnOnce(Result<()>) + 'static,
505    ) {
506        let mut app = DesktopApp::new(
507            runtime,
508            self.renderer,
509            self.automation,
510            self.extensions,
511            event_loop_proxy,
512            external_wake_pending,
513            reactive_wake_pending,
514        );
515        app.web_canvas = self.web_canvas;
516        wasm_bindgen_futures::spawn_local(async move {
517            if let Err(error) = app.renderer.initialize_async(None).await {
518                on_exit(Err(error));
519                return;
520            }
521            app.on_exit = Some(Box::new(on_exit));
522            event_loop.spawn_app(app);
523        });
524    }
525
526    /// Start the application without blocking: the caller drives the event
527    /// loop by calling [`PumpedDesktop::pump`] repeatedly, for example from
528    /// another framework's event loop.
529    ///
530    /// Like [`run_with`](Self::run_with), this must be called on the main
531    /// thread, and only once per process.
532    #[cfg(any(target_os = "windows", target_os = "macos", target_os = "linux"))]
533    pub fn start_pumped(
534        self,
535        mut runtime: Runtime,
536        on_ready: impl FnOnce(CommandSender),
537    ) -> Result<PumpedDesktop> {
538        let (event_loop, event_loop_proxy, external_wake_pending, reactive_wake_pending) =
539            create_event_loop(&mut runtime, on_ready)?;
540        let app = DesktopApp::new(
541            runtime,
542            self.renderer,
543            self.automation,
544            self.extensions,
545            event_loop_proxy,
546            external_wake_pending,
547            reactive_wake_pending,
548        );
549        Ok(PumpedDesktop {
550            event_loop,
551            app,
552            exited: false,
553        })
554    }
555
556    #[cfg(target_os = "android")]
557    pub fn run_android_with(
558        self,
559        mut runtime: Runtime,
560        android_app: AndroidApp,
561        on_ready: impl FnOnce(CommandSender),
562    ) -> Result<Vec<PlatformWindow>> {
563        runtime.set_clipboard_backend(crate::android_clipboard::AndroidClipboardBackend::new(
564            android_app.clone(),
565        ));
566        runtime.set_url_opener_backend(crate::android_url_opener::AndroidUrlOpenerBackend::new(
567            android_app.clone(),
568        ));
569        crate::android_file_dialog::set_android_app(android_app.clone());
570        let mut event_loop_builder = EventLoop::<DesktopUserEvent>::with_user_event();
571        event_loop_builder.with_android_app(android_app);
572        let event_loop = event_loop_builder.build().map_err(map_event_loop_error)?;
573        let event_loop_proxy = event_loop.create_proxy();
574        let external_wake_pending = Arc::new(AtomicBool::new(false));
575        let reactive_wake_pending = Arc::new(AtomicBool::new(false));
576        let waker = Waker::new(
577            event_loop_proxy.clone(),
578            external_wake_pending.clone(),
579            WakeKind::External,
580        );
581        let reactive_waker = Waker::new(
582            event_loop_proxy.clone(),
583            reactive_wake_pending.clone(),
584            WakeKind::Reactive,
585        );
586        runtime.set_external_waker(move || reactive_waker.wake());
587        let commands = runtime.command_sender();
588        let command_waker = waker.clone();
589        runtime.set_command_waker(move || command_waker.wake());
590        on_ready(commands);
591
592        let mut app = DesktopApp::new(
593            runtime,
594            self.renderer,
595            self.automation,
596            self.extensions,
597            event_loop_proxy,
598            external_wake_pending,
599            reactive_wake_pending,
600        );
601        event_loop.run_app(&mut app).map_err(map_event_loop_error)?;
602
603        if let Some(error) = app.last_error.take() {
604            return Err(error);
605        }
606
607        Ok(app.snapshot_windows())
608    }
609}
610
611/// Create the event loop and connect the runtime's wakers to it.
612#[allow(clippy::type_complexity)]
613fn create_event_loop(
614    runtime: &mut Runtime,
615    on_ready: impl FnOnce(CommandSender),
616) -> Result<(
617    EventLoop<DesktopUserEvent>,
618    EventLoopProxy<DesktopUserEvent>,
619    Arc<AtomicBool>,
620    Arc<AtomicBool>,
621)> {
622    let event_loop = EventLoop::<DesktopUserEvent>::with_user_event()
623        .build()
624        .map_err(map_event_loop_error)?;
625    let event_loop_proxy = event_loop.create_proxy();
626    let external_wake_pending = Arc::new(AtomicBool::new(false));
627    let reactive_wake_pending = Arc::new(AtomicBool::new(false));
628    let waker = Waker::new(
629        event_loop_proxy.clone(),
630        external_wake_pending.clone(),
631        WakeKind::External,
632    );
633    let reactive_waker = Waker::new(
634        event_loop_proxy.clone(),
635        reactive_wake_pending.clone(),
636        WakeKind::Reactive,
637    );
638    runtime.set_external_waker(move || reactive_waker.wake());
639    let commands = runtime.command_sender();
640    let command_waker = waker.clone();
641    runtime.set_command_waker(move || command_waker.wake());
642    on_ready(commands);
643    Ok((
644        event_loop,
645        event_loop_proxy,
646        external_wake_pending,
647        reactive_wake_pending,
648    ))
649}
650
651/// What a host should do after [`PumpedDesktop::pump`].
652#[derive(Debug, Clone, Copy, PartialEq, Eq)]
653pub enum DesktopPumpStatus {
654    /// Keep pumping. `next_wake` is how soon the application needs another
655    /// turn for its own timers and animations; `None` means only new
656    /// platform events, such as input, need attention.
657    Continue { next_wake: Option<Duration> },
658    /// The application exited. Pumping again does nothing.
659    Exited,
660}
661
662/// A desktop application that its host drives one event-loop turn at a time
663/// with [`pump`](Self::pump), instead of blocking in
664/// [`DesktopPlatform::run_with`].
665#[cfg(any(target_os = "windows", target_os = "macos", target_os = "linux"))]
666pub struct PumpedDesktop {
667    event_loop: EventLoop<DesktopUserEvent>,
668    app: DesktopApp,
669    exited: bool,
670}
671
672#[cfg(any(target_os = "windows", target_os = "macos", target_os = "linux"))]
673impl PumpedDesktop {
674    /// Process pending events and due work, waiting up to `timeout` for new
675    /// events (`None` waits indefinitely, so hosts usually pass a short or
676    /// zero timeout). Returns an error the application stopped with.
677    pub fn pump(&mut self, timeout: Option<Duration>) -> Result<DesktopPumpStatus> {
678        use winit::platform::pump_events::{EventLoopExtPumpEvents, PumpStatus};
679
680        if self.exited {
681            return Ok(DesktopPumpStatus::Exited);
682        }
683        let status = self.event_loop.pump_app_events(timeout, &mut self.app);
684        if let Some(error) = self.app.last_error.take() {
685            self.exited = true;
686            return Err(error);
687        }
688        match status {
689            PumpStatus::Exit(_) => {
690                self.exited = true;
691                Ok(DesktopPumpStatus::Exited)
692            }
693            PumpStatus::Continue => Ok(DesktopPumpStatus::Continue {
694                next_wake: self
695                    .app
696                    .next_wake
697                    .get()
698                    .map(|at| at.saturating_duration_since(Instant::now())),
699            }),
700        }
701    }
702
703    /// Whether the application has exited.
704    pub fn has_exited(&self) -> bool {
705        self.exited
706    }
707
708    /// The application's windows as of the last turn.
709    pub fn windows(&self) -> Vec<PlatformWindow> {
710        self.app.snapshot_windows()
711    }
712}
713
714struct DesktopApp {
715    runtime: Runtime,
716    renderer: WgpuRenderer,
717    // Native children owned by extensions must drop before their parent
718    // windows, so this field intentionally precedes `windows`.
719    extensions: Vec<Box<dyn DesktopExtension>>,
720    #[cfg(target_os = "windows")]
721    accesskit_event_proxy: EventLoopProxy<DesktopUserEvent>,
722    automation: Option<DesktopAutomationState>,
723    started_at: Instant,
724    frame_clock: f64,
725    host_lifecycle: HostLifecycle,
726    windows: HashMap<WindowId, WindowState>,
727    host_to_runtime: HashMap<HostWindowId, WindowId>,
728    #[cfg(target_os = "windows")]
729    closing_windows: HashSet<HostWindowId>,
730    last_error: Option<Error>,
731    external_wake_pending: Arc<AtomicBool>,
732    reactive_wake_pending: Arc<AtomicBool>,
733    /// When the application next needs a turn for its own work, as of the
734    /// latest control-flow update: `None` waits for events.
735    next_wake: Cell<Option<Instant>>,
736    /// The canvas for the next window created in the browser.
737    #[cfg(target_arch = "wasm32")]
738    web_canvas: Option<web_sys::HtmlCanvasElement>,
739    /// Whether a window already uses the page's `sui-main-canvas` element.
740    #[cfg(target_arch = "wasm32")]
741    web_main_canvas_used: bool,
742    /// Runs when the browser's event loop finishes the app.
743    #[cfg(target_arch = "wasm32")]
744    on_exit: Option<Box<dyn FnOnce(Result<()>)>>,
745}
746
747impl DesktopApp {
748    #[cfg(target_arch = "wasm32")]
749    fn web_viewport_logical_size() -> LogicalSize<f64> {
750        Self::web_canvas_logical_size(None).unwrap_or_else(Self::web_window_logical_size)
751    }
752
753    #[cfg(target_arch = "wasm32")]
754    fn web_window_logical_size() -> LogicalSize<f64> {
755        let width = web_sys::window()
756            .and_then(|window| window.inner_width().ok())
757            .and_then(|value| value.as_f64())
758            .unwrap_or(DesktopPlatform::DEFAULT_WINDOW_SIZE.width as f64)
759            .max(1.0);
760        let height = web_sys::window()
761            .and_then(|window| window.inner_height().ok())
762            .and_then(|value| value.as_f64())
763            .unwrap_or(DesktopPlatform::DEFAULT_WINDOW_SIZE.height as f64)
764            .max(1.0);
765
766        LogicalSize::new(width, height)
767    }
768
769    #[cfg(target_arch = "wasm32")]
770    fn web_element_logical_size(element: &web_sys::Element) -> Option<LogicalSize<f64>> {
771        let rect = element.get_bounding_client_rect();
772        let width = rect.width();
773        let height = rect.height();
774        if width.is_finite() && height.is_finite() && width > 0.0 && height > 0.0 {
775            return Some(LogicalSize::new(width, height));
776        }
777
778        let width = f64::from(element.client_width());
779        let height = f64::from(element.client_height());
780        if width.is_finite() && height.is_finite() && width > 0.0 && height > 0.0 {
781            return Some(LogicalSize::new(width, height));
782        }
783
784        None
785    }
786
787    #[cfg(target_arch = "wasm32")]
788    fn web_element_is_document_sizing_root(element: &web_sys::Element) -> bool {
789        matches!(
790            element.tag_name().to_ascii_lowercase().as_str(),
791            "body" | "html"
792        )
793    }
794
795    #[cfg(target_arch = "wasm32")]
796    fn web_find_resize_container(element: &web_sys::Element) -> Option<web_sys::Element> {
797        let mut current = Some(element.clone());
798        while let Some(candidate) = current {
799            if candidate.has_attribute("data-sui-resize-container") {
800                return Some(candidate);
801            }
802            current = candidate.parent_element();
803        }
804        None
805    }
806
807    #[cfg(target_arch = "wasm32")]
808    fn web_canvas_sizing_element(canvas: &web_sys::HtmlCanvasElement) -> Option<web_sys::Element> {
809        let canvas_element = canvas.clone().dyn_into::<web_sys::Element>().ok()?;
810        if let Some(container) = Self::web_find_resize_container(&canvas_element) {
811            return Some(container);
812        }
813
814        let root = web_sys::window()
815            .and_then(|window| window.document())
816            .and_then(|document| document.get_element_by_id("sui-root"));
817
818        if let Some(root) = root {
819            if let Some(parent) = root.parent_element()
820                && !Self::web_element_is_document_sizing_root(&parent)
821                && Self::web_element_logical_size(&parent).is_some()
822            {
823                return Some(parent);
824            }
825            return Some(root);
826        }
827
828        canvas.parent_element().or(Some(canvas_element))
829    }
830
831    #[cfg(target_arch = "wasm32")]
832    fn web_canvas_logical_size(
833        canvas: Option<&web_sys::HtmlCanvasElement>,
834    ) -> Option<LogicalSize<f64>> {
835        let canvas = canvas.cloned().or_else(|| {
836            web_sys::window()?
837                .document()
838                .and_then(|document| document.get_element_by_id("sui-main-canvas"))
839                .and_then(|element| element.dyn_into::<web_sys::HtmlCanvasElement>().ok())
840        })?;
841        let canvas_element: &web_sys::Element = canvas.as_ref();
842
843        Self::web_canvas_sizing_element(&canvas)
844            .as_ref()
845            .and_then(Self::web_element_logical_size)
846            .or_else(|| Self::web_element_logical_size(canvas_element))
847            .or_else(|| {
848                canvas
849                    .parent_element()
850                    .as_ref()
851                    .and_then(Self::web_element_logical_size)
852            })
853    }
854
855    /// The canvas for a new window: the configured canvas, else the page's
856    /// `sui-main-canvas` element for the first window. `None` lets winit
857    /// create a canvas and append it to the page.
858    #[cfg(target_arch = "wasm32")]
859    fn web_canvas_for_window(&mut self) -> Option<web_sys::HtmlCanvasElement> {
860        let window = web_sys::window()?;
861        let canvas = match self.web_canvas.take() {
862            Some(canvas) => canvas,
863            None if !self.web_main_canvas_used => {
864                self.web_main_canvas_used = true;
865                window
866                    .document()
867                    .and_then(|document| document.get_element_by_id("sui-main-canvas"))
868                    .and_then(|element| element.dyn_into::<web_sys::HtmlCanvasElement>().ok())?
869            }
870            None => return None,
871        };
872        let scale_factor = window.device_pixel_ratio().max(1.0);
873        let size = Self::web_canvas_logical_size(Some(&canvas))
874            .unwrap_or_else(Self::web_window_logical_size);
875        let width = size.width;
876        let height = size.height;
877        canvas.set_width(((width * scale_factor).round().max(1.0)) as u32);
878        canvas.set_height(((height * scale_factor).round().max(1.0)) as u32);
879        Some(canvas)
880    }
881
882    #[cfg(target_arch = "wasm32")]
883    fn initial_web_physical_size(window: &Window) -> PhysicalSize<u32> {
884        window
885            .canvas()
886            .map(|canvas| PhysicalSize::new(canvas.width().max(1), canvas.height().max(1)))
887            .unwrap_or_else(|| window.inner_size())
888    }
889
890    #[cfg(not(target_arch = "wasm32"))]
891    fn initial_window_physical_size(window: &Window) -> PhysicalSize<u32> {
892        window.inner_size()
893    }
894
895    #[cfg(target_arch = "wasm32")]
896    fn initial_window_physical_size(window: &Window) -> PhysicalSize<u32> {
897        Self::initial_web_physical_size(window)
898    }
899
900    fn new(
901        runtime: Runtime,
902        renderer: WgpuRenderer,
903        automation: Option<DesktopAutomationConfig>,
904        extensions: Vec<Box<dyn DesktopExtension>>,
905        event_loop_proxy: EventLoopProxy<DesktopUserEvent>,
906        external_wake_pending: Arc<AtomicBool>,
907        reactive_wake_pending: Arc<AtomicBool>,
908    ) -> Self {
909        #[cfg(any(target_os = "windows", target_os = "macos", target_os = "linux"))]
910        {
911            runtime.set_clipboard_backend(crate::os_clipboard::OsClipboardBackend::new());
912            runtime.set_url_opener_backend(crate::os_url_opener::OsUrlOpenerBackend::new());
913        }
914
915        #[cfg(target_arch = "wasm32")]
916        {
917            runtime.set_clipboard_backend(crate::web_interop::WebClipboardBackend::default());
918            runtime.set_url_opener_backend(crate::web_interop::WebUrlOpenerBackend);
919        }
920
921        #[cfg(not(target_os = "windows"))]
922        let _ = event_loop_proxy;
923
924        Self {
925            runtime,
926            renderer,
927            extensions,
928            #[cfg(target_os = "windows")]
929            accesskit_event_proxy: event_loop_proxy,
930            automation: automation.map(DesktopAutomationState::new),
931            started_at: Instant::now(),
932            frame_clock: 0.0,
933            host_lifecycle: HostLifecycle::default(),
934            windows: HashMap::new(),
935            host_to_runtime: HashMap::new(),
936            #[cfg(target_os = "windows")]
937            closing_windows: HashSet::new(),
938            last_error: None,
939            next_wake: Cell::new(None),
940            #[cfg(target_arch = "wasm32")]
941            web_canvas: None,
942            #[cfg(target_arch = "wasm32")]
943            web_main_canvas_used: false,
944            #[cfg(target_arch = "wasm32")]
945            on_exit: None,
946            external_wake_pending,
947            reactive_wake_pending,
948        }
949    }
950
951    #[cfg_attr(target_arch = "wasm32", allow(dead_code))]
952    fn snapshot_windows(&self) -> Vec<PlatformWindow> {
953        self.windows.values().map(WindowState::snapshot).collect()
954    }
955
956    fn refresh_window_display_capabilities(&mut self, window_id: WindowId) -> Result<()> {
957        let capabilities = self
958            .windows
959            .get(&window_id)
960            .map(|window| detect_window_display_capabilities(window.window.as_ref()))
961            .ok_or_else(|| Error::new(format!("missing window {}", window_id.get())))?;
962        self.renderer
963            .set_window_display_capabilities(window_id, capabilities)?;
964        Ok(())
965    }
966
967    fn restore_window_surfaces(&mut self, event_loop: &ActiveEventLoop) -> Result<()> {
968        let runtime_window_ids = self.runtime.window_ids();
969        let window_ids: Vec<_> = self
970            .windows
971            .keys()
972            .copied()
973            .filter(|window_id| runtime_window_ids.contains(window_id))
974            .collect();
975
976        for window_id in window_ids {
977            let window = Arc::clone(&self.windows[&window_id].window);
978            self.renderer
979                .register_window(window_id, Arc::clone(&window))?;
980            self.refresh_window_display_capabilities(window_id)?;
981
982            let scale_factor = window.scale_factor();
983            let physical_size = Self::initial_window_physical_size(&window);
984            let size = physical_size_to_logical_size(physical_size, scale_factor);
985            let mut unchanged = false;
986            if let Some(state) = self.windows.get_mut(&window_id) {
987                unchanged = state.scale_factor == scale_factor
988                    && state.suspended_size.take() == Some(physical_size);
989                state.scale_factor = scale_factor;
990                state.display_capabilities_dirty = false;
991                state.redraw_requested = false;
992                state.redraw_requested_at_ms = None;
993                state.present_pending = unchanged;
994            }
995            if unchanged {
996                // Layout and the retained scene still fit the window; only
997                // the new surface needs the current frame.
998                window.request_redraw();
999                continue;
1000            }
1001
1002            // The window changed while suspended. Re-delivering its current
1003            // scale and size invalidates layout/paint and schedules a fresh frame
1004            // without replacing the retained runtime or widget tree.
1005            self.process_event(
1006                event_loop,
1007                window_id,
1008                Event::Window(WindowEvent::ScaleFactorChanged {
1009                    scale_factor,
1010                    raw_dpi: None,
1011                    suggested_size: Some(size),
1012                }),
1013            )?;
1014            self.process_event(
1015                event_loop,
1016                window_id,
1017                Event::Window(WindowEvent::Resized(size)),
1018            )?;
1019        }
1020
1021        Ok(())
1022    }
1023
1024    fn suspend_window_surfaces(&mut self) -> Result<()> {
1025        if !self.host_lifecycle.suspend() {
1026            return Ok(());
1027        }
1028
1029        for extension in &mut self.extensions {
1030            extension.suspended()?;
1031        }
1032
1033        let window_ids = self.windows.keys().copied().collect::<Vec<_>>();
1034        for window_id in window_ids {
1035            if let Err(error) = self
1036                .runtime
1037                .handle_event(window_id, Event::Window(WindowEvent::Focused(false)))
1038            {
1039                self.last_error = Some(error);
1040            }
1041        }
1042
1043        for (window_id, window) in &mut self.windows {
1044            // On Android the native SurfaceView is invalid as soon as this
1045            // callback returns. Drop wgpu surfaces synchronously while retaining
1046            // the host window, SUI runtime state, and the renderer's retained
1047            // scene for the next Resumed event.
1048            self.renderer.suspend_window(*window_id);
1049            window.suspended_size = Some(window.window.inner_size());
1050            window.display_capabilities_dirty = true;
1051            window.redraw_requested = false;
1052            window.redraw_requested_at_ms = None;
1053            window.android_back_down_seen = false;
1054            release_host_cursor(window);
1055            if window.ime_allowed {
1056                window.window.set_ime_allowed(false);
1057                window.ime_allowed = false;
1058            }
1059        }
1060        // A backgrounded app is a likely target for the system to reclaim;
1061        // keep only what makes returning to it fast.
1062        self.renderer.trim_memory(MemoryTrimLevel::Background);
1063
1064        Ok(())
1065    }
1066
1067    fn sync_extensions(&mut self) -> Result<()> {
1068        let commands = self.runtime.command_sender();
1069        let runtime = &self.runtime;
1070        let windows = &self.windows;
1071        for extension in &mut self.extensions {
1072            extension.update(DesktopExtensionContext {
1073                runtime,
1074                renderer: &self.renderer,
1075                windows,
1076                commands: &commands,
1077            })?;
1078        }
1079        Ok(())
1080    }
1081
1082    fn sync_windows(&mut self, event_loop: &ActiveEventLoop) -> Result<()> {
1083        let runtime_window_ids = self.runtime.window_ids();
1084
1085        let removed_ids: Vec<_> = self
1086            .windows
1087            .keys()
1088            .copied()
1089            .filter(|window_id| !runtime_window_ids.contains(window_id))
1090            .collect();
1091
1092        for window_id in removed_ids {
1093            if let Some(mut window) = self.windows.remove(&window_id) {
1094                // Winit posts window destruction to the Windows message queue.
1095                // Keep pumping until Destroyed arrives, even for the last window.
1096                #[cfg(target_os = "windows")]
1097                self.closing_windows.insert(window.window.id());
1098                release_host_cursor(&mut window);
1099                #[cfg(any(target_os = "windows", target_os = "macos", target_os = "linux"))]
1100                crate::file_dialog::unregister_native_file_dialog_parent(window_id);
1101                self.renderer.remove_window(window_id);
1102                self.host_to_runtime.remove(&window.window.id());
1103                crate::clear_window_performance(window_id);
1104            }
1105        }
1106
1107        for window_id in runtime_window_ids {
1108            if self.windows.contains_key(&window_id) {
1109                continue;
1110            }
1111
1112            let title = self.runtime.window_title(window_id)?.to_string();
1113            let window_icon = self.runtime.window_icon(window_id)?.cloned();
1114            #[cfg(target_arch = "wasm32")]
1115            let initial_size = Self::web_viewport_logical_size();
1116            #[cfg(not(target_arch = "wasm32"))]
1117            let requested_size = self
1118                .runtime
1119                .window_initial_size(window_id)?
1120                .unwrap_or(DesktopPlatform::DEFAULT_WINDOW_SIZE);
1121            #[cfg(not(target_arch = "wasm32"))]
1122            let monitors = event_loop.available_monitors().collect::<Vec<_>>();
1123            #[cfg(not(target_arch = "wasm32"))]
1124            let (initial_size, initial_position) = safe_initial_window_placement(
1125                requested_size,
1126                self.runtime.window_initial_position(window_id)?,
1127                &monitors,
1128            );
1129            #[cfg(not(target_arch = "wasm32"))]
1130            let initial_size = LogicalSize::new(initial_size.width, initial_size.height);
1131            #[allow(unused_mut)]
1132            let mut attributes = WindowAttributes::default()
1133                .with_title(title.clone())
1134                .with_inner_size(initial_size);
1135            #[cfg(not(target_arch = "wasm32"))]
1136            if let Some(position) = initial_position {
1137                attributes = attributes.with_position(PhysicalPosition::new(
1138                    f64::from(position.x),
1139                    f64::from(position.y),
1140                ));
1141            }
1142            #[cfg(target_os = "windows")]
1143            {
1144                // AccessKit must attach its native provider before the HWND is shown for
1145                // the first time. The window is made visible after the adapter and the
1146                // renderer-backed WindowState have both been installed below.
1147                attributes = attributes.with_visible(false);
1148            }
1149            #[cfg(not(target_arch = "wasm32"))]
1150            {
1151                attributes = attributes.with_window_icon(
1152                    window_icon
1153                        .as_ref()
1154                        .map(window_icon_to_winit_icon)
1155                        .transpose()?,
1156                );
1157            }
1158            #[cfg(target_arch = "wasm32")]
1159            {
1160                install_web_favicon(window_icon.as_ref())?;
1161                let canvas = self.web_canvas_for_window();
1162                let append = canvas.is_none();
1163                attributes = attributes.with_canvas(canvas).with_append(append);
1164            }
1165            let window = Arc::new(event_loop.create_window(attributes).map_err(map_os_error)?);
1166            window.set_ime_allowed(false);
1167
1168            let host_id = window.id();
1169            let scale_factor = window.scale_factor();
1170            let size = physical_size_to_logical_size(
1171                Self::initial_window_physical_size(&window),
1172                scale_factor,
1173            );
1174            #[cfg(target_os = "windows")]
1175            let accesskit_adapter = AccessKitAdapter::with_event_loop_proxy(
1176                event_loop,
1177                window.as_ref(),
1178                self.accesskit_event_proxy.clone(),
1179            );
1180            #[cfg(target_os = "windows")]
1181            let accesskit_snapshot = build_accesskit_snapshot(window_id, scale_factor, &title, &[]);
1182            // Interop clients may create GPU resources during initial layout.
1183            // Keep their context available at the original boundary; ordinary
1184            // windows can overlap device setup with the size/DPI layout below.
1185            let prepare_in_background = self.renderer.external_texture_registry().is_none();
1186            if prepare_in_background {
1187                self.renderer
1188                    .prepare_window(window_id, Arc::clone(&window))?;
1189            } else {
1190                self.renderer
1191                    .register_window(window_id, Arc::clone(&window))?;
1192            }
1193            #[cfg(any(target_os = "windows", target_os = "macos", target_os = "linux"))]
1194            crate::file_dialog::register_native_file_dialog_parent(window_id, &window);
1195
1196            self.host_to_runtime.insert(host_id, window_id);
1197            self.windows.insert(
1198                window_id,
1199                WindowState {
1200                    id: window_id,
1201                    title,
1202                    display_capabilities_dirty: false,
1203                    awaiting_performance_bootstrap: true,
1204                    redraw_requested: false,
1205                    redraw_requested_at_ms: None,
1206                    frame_index: 0,
1207                    pending_event_time_ms: 0.0,
1208                    last_non_redraw_event_at_ms: None,
1209                    occluded: false,
1210                    accessibility: AccessibilityBridge::default(),
1211                    #[cfg(target_os = "windows")]
1212                    accesskit_adapter,
1213                    #[cfg(target_os = "windows")]
1214                    accesskit_snapshot,
1215                    pointer: PointerState::default(),
1216                    focused: false,
1217                    applied_cursor_grab: CursorGrabMode::None,
1218                    applied_cursor_revision: 0,
1219                    touch_points: HashMap::new(),
1220                    android_back_down_seen: false,
1221                    suspended_size: None,
1222                    present_pending: false,
1223                    ime_allowed: false,
1224                    scale_factor,
1225                    refresh_interval: monitor_refresh_interval(&window),
1226                    cadence: FrameCadence::default(),
1227                    frame_pacing: FramePacing::Timer,
1228                    window,
1229                },
1230            );
1231            if !prepare_in_background {
1232                self.refresh_window_display_capabilities(window_id)?;
1233                #[cfg(target_os = "windows")]
1234                self.windows[&window_id].window.set_visible(true);
1235            }
1236            self.process_event(
1237                event_loop,
1238                window_id,
1239                Event::Window(WindowEvent::ScaleFactorChanged {
1240                    scale_factor,
1241                    raw_dpi: None,
1242                    suggested_size: Some(size),
1243                }),
1244            )?;
1245
1246            self.process_event(
1247                event_loop,
1248                window_id,
1249                Event::Window(WindowEvent::Resized(size)),
1250            )?;
1251            if prepare_in_background {
1252                self.renderer
1253                    .register_window(window_id, Arc::clone(&self.windows[&window_id].window))?;
1254                self.refresh_window_display_capabilities(window_id)?;
1255                #[cfg(target_os = "windows")]
1256                self.windows[&window_id].window.set_visible(true);
1257            }
1258        }
1259
1260        self.exit_if_windows_closed(event_loop);
1261
1262        Ok(())
1263    }
1264
1265    fn exit_if_windows_closed(&self, event_loop: &ActiveEventLoop) {
1266        if !self.windows.is_empty() {
1267            return;
1268        }
1269        #[cfg(target_os = "windows")]
1270        if !self.closing_windows.is_empty() {
1271            event_loop.set_control_flow(ControlFlow::Wait);
1272            return;
1273        }
1274        event_loop.exit();
1275    }
1276
1277    fn drive_runtime(&mut self, event_loop: &ActiveEventLoop) -> Result<()> {
1278        if self.runtime.exit_requested() {
1279            event_loop.exit();
1280            return Ok(());
1281        }
1282
1283        // Winit may deliver AboutToWait and user events before the first
1284        // Resumed callback. In particular, Android has no native window (and
1285        // therefore cannot create a wgpu surface) during that interval.
1286        if !self.host_lifecycle.is_resumed() {
1287            event_loop.set_control_flow(ControlFlow::Wait);
1288            return Ok(());
1289        }
1290
1291        self.sync_windows(event_loop)?;
1292        if self.windows.is_empty() {
1293            return Ok(());
1294        }
1295
1296        self.update_clock();
1297        self.runtime.tick(self.frame_clock);
1298
1299        while self.dispatch_ready_events(event_loop)? {}
1300
1301        self.sync_windows(event_loop)?;
1302
1303        self.sync_extensions()?;
1304
1305        #[cfg(target_arch = "wasm32")]
1306        self.process_web_interop_commands(event_loop)?;
1307
1308        let window_ids: Vec<_> = self.windows.keys().copied().collect();
1309        for window_id in window_ids.iter().copied() {
1310            self.sync_frame_pacing(window_id)?;
1311            self.request_redraw_if_needed(window_id)?;
1312        }
1313
1314        self.drive_automation(event_loop)?;
1315        if self
1316            .automation
1317            .as_ref()
1318            .is_some_and(|automation| automation.shutdown_requested)
1319        {
1320            let window_ids = self.runtime.window_ids();
1321            for window_id in window_ids {
1322                self.runtime.remove_window(window_id)?;
1323                crate::clear_window_performance(window_id);
1324            }
1325            self.sync_windows(event_loop)?;
1326            return Ok(());
1327        }
1328
1329        self.update_control_flow(event_loop)?;
1330        Ok(())
1331    }
1332
1333    fn dispatch_ready_events(&mut self, event_loop: &ActiveEventLoop) -> Result<bool> {
1334        let events = self.runtime.drain_ready_events();
1335        let had_events = !events.is_empty();
1336        for (window_id, event) in events {
1337            if self.windows.contains_key(&window_id) {
1338                self.process_event(event_loop, window_id, event)?;
1339            }
1340        }
1341        Ok(had_events)
1342    }
1343
1344    /// Pace animation frames by the display while the window presents with
1345    /// vsync, and by the runtime's timer when it is hidden or unsynchronized
1346    /// (a hidden window gets no redraws to pace by).
1347    fn sync_frame_pacing(&mut self, window_id: WindowId) -> Result<()> {
1348        let vsync = self.renderer.vsync_enabled();
1349        let Some(window) = self.windows.get_mut(&window_id) else {
1350            return Ok(());
1351        };
1352        let size = window.window.inner_size();
1353        let presenting = !window.occluded
1354            && window.window.is_minimized() != Some(true)
1355            && size.width > 0
1356            && size.height > 0;
1357        let pacing = if vsync && presenting {
1358            FramePacing::Display
1359        } else {
1360            FramePacing::Timer
1361        };
1362        if window.frame_pacing != pacing {
1363            window.frame_pacing = pacing;
1364            window.cadence = FrameCadence::default();
1365            self.runtime.set_frame_pacing(window_id, pacing)?;
1366        }
1367        Ok(())
1368    }
1369
1370    /// Start a display-paced animation frame before rendering, stamped with
1371    /// the time the frame should reach the screen.
1372    fn begin_display_paced_frame(
1373        &mut self,
1374        event_loop: &ActiveEventLoop,
1375        window_id: WindowId,
1376    ) -> Result<()> {
1377        let now = self.frame_clock;
1378        let Some(window) = self.windows.get_mut(&window_id) else {
1379            return Ok(());
1380        };
1381        if window.frame_pacing != FramePacing::Display
1382            || !self.runtime.has_pending_animation_frames(window_id)?
1383        {
1384            return Ok(());
1385        }
1386        let frame_time = window.cadence.next(now, window.refresh_interval);
1387        for event in self.runtime.begin_animation_frame(window_id, frame_time)? {
1388            self.process_event(event_loop, window_id, event)?;
1389        }
1390        Ok(())
1391    }
1392
1393    fn request_redraw_if_needed(&mut self, window_id: WindowId) -> Result<()> {
1394        // A focused VSync window must keep presenting even when its retained UI
1395        // is unchanged. Otherwise windowed VRR can lower the whole monitor's
1396        // refresh rate while the user is interacting with an idle view. Android
1397        // and the web have no shared desktop monitor to protect (the browser
1398        // owns presentation pacing); continuous presentation there wastes
1399        // CPU/GPU and battery even when the scene is unchanged.
1400        let keep_presenting = !cfg!(any(target_os = "android", target_arch = "wasm32"))
1401            && self.renderer.vsync_enabled()
1402            && self
1403                .windows
1404                .get(&window_id)
1405                .is_some_and(|window| window.focused);
1406        // Display-paced animation needs a redraw to start its next frame,
1407        // even before anything has been invalidated.
1408        let animating = self
1409            .windows
1410            .get(&window_id)
1411            .is_some_and(|window| window.frame_pacing == FramePacing::Display)
1412            && self.runtime.has_pending_animation_frames(window_id)?;
1413        let capturing = crate::has_pending_window_debug_captures(window_id);
1414        let present_pending = self
1415            .windows
1416            .get(&window_id)
1417            .is_some_and(|window| window.present_pending);
1418        if !self.runtime.needs_render(window_id)?
1419            && !keep_presenting
1420            && !animating
1421            && !capturing
1422            && !present_pending
1423        {
1424            return Ok(());
1425        }
1426
1427        let now_ms = self.current_time_ms();
1428
1429        let Some(window) = self.windows.get_mut(&window_id) else {
1430            return Ok(());
1431        };
1432
1433        let size = window.window.inner_size();
1434        if window.occluded
1435            || window.window.is_minimized() == Some(true)
1436            || size.width == 0
1437            || size.height == 0
1438        {
1439            return Ok(());
1440        }
1441        if window.redraw_requested {
1442            return Ok(());
1443        }
1444
1445        window.redraw_requested = true;
1446        window.redraw_requested_at_ms = Some(now_ms);
1447        window.window.request_redraw();
1448        Ok(())
1449    }
1450
1451    fn update_clock(&mut self) {
1452        self.frame_clock = self.started_at.elapsed().as_secs_f64();
1453    }
1454
1455    fn current_time_ms(&self) -> f64 {
1456        self.started_at.elapsed().as_secs_f64() * 1000.0
1457    }
1458
1459    fn update_control_flow(&self, event_loop: &ActiveEventLoop) -> Result<()> {
1460        if self.windows.is_empty() {
1461            self.exit_if_windows_closed(event_loop);
1462            return Ok(());
1463        }
1464
1465        let mut next_deadline: Option<f64> = None;
1466
1467        for window_id in self.runtime.window_ids() {
1468            let deadline = self.runtime.next_wakeup_time(window_id)?;
1469            next_deadline = match (next_deadline, deadline) {
1470                (Some(current), Some(candidate)) => Some(current.min(candidate)),
1471                (None, Some(candidate)) => Some(candidate),
1472                (current, None) => current,
1473            };
1474        }
1475
1476        if let Some(automation_deadline) = self
1477            .automation
1478            .as_ref()
1479            .and_then(DesktopAutomationState::next_deadline)
1480        {
1481            let candidate = (automation_deadline - self.started_at).as_secs_f64();
1482            next_deadline = match next_deadline {
1483                Some(current) => Some(current.min(candidate)),
1484                None => Some(candidate),
1485            };
1486        }
1487
1488        if let Some(interval) = self
1489            .extensions
1490            .iter()
1491            .filter_map(|extension| extension.poll_interval())
1492            .min()
1493        {
1494            let candidate = self.frame_clock + interval.as_secs_f64();
1495            next_deadline = match next_deadline {
1496                Some(current) => Some(current.min(candidate)),
1497                None => Some(candidate),
1498            };
1499        }
1500
1501        match next_deadline {
1502            Some(deadline) if deadline <= self.frame_clock => {
1503                self.next_wake.set(Some(Instant::now()));
1504                event_loop.set_control_flow(ControlFlow::Poll);
1505            }
1506            Some(deadline) => {
1507                let when = self.started_at + Duration::from_secs_f64(deadline.max(0.0));
1508                self.next_wake.set(Some(when));
1509                event_loop.set_control_flow(ControlFlow::WaitUntil(when));
1510            }
1511            None => {
1512                self.next_wake.set(None);
1513                event_loop.set_control_flow(ControlFlow::Wait);
1514            }
1515        }
1516
1517        Ok(())
1518    }
1519
1520    fn process_event(
1521        &mut self,
1522        event_loop: &ActiveEventLoop,
1523        window_id: WindowId,
1524        event: Event,
1525    ) -> Result<()> {
1526        self.process_event_with_outcome(event_loop, window_id, event)
1527            .map(|_| ())
1528    }
1529
1530    fn process_event_with_outcome(
1531        &mut self,
1532        event_loop: &ActiveEventLoop,
1533        window_id: WindowId,
1534        event: Event,
1535    ) -> Result<bool> {
1536        if !self.windows.contains_key(&window_id) {
1537            return Ok(false);
1538        }
1539
1540        let event_arrived_at_ms = self.current_time_ms();
1541
1542        let is_redraw = matches!(event, Event::Window(WindowEvent::RedrawRequested));
1543        let is_close = matches!(event, Event::Window(WindowEvent::CloseRequested));
1544
1545        // Event handlers start widget motion from EventCtx::current_time(). Keep that
1546        // time current for input after the event loop has been idle, not only for
1547        // redraw and ready-event delivery.
1548        self.update_clock();
1549        self.runtime.tick(self.frame_clock);
1550
1551        if is_redraw {
1552            // Windows can deliver WM_PAINT inside its modal move/resize loop
1553            // without AboutToWait. Advance one batch of due wakes so animation
1554            // and timers do not freeze while the title bar or border is held.
1555            // Do not chase newly scheduled future deadlines in this callback.
1556            self.dispatch_ready_events(event_loop)?;
1557            self.begin_display_paced_frame(event_loop, window_id)?;
1558        }
1559
1560        let event_started = Instant::now();
1561        let handled = self.runtime.dispatch_event(window_id, event)?;
1562        let event_time_ms = event_started.elapsed().as_secs_f64() * 1000.0;
1563
1564        self.sync_window_cursor(window_id)?;
1565
1566        // Idle pointer motion can run for seconds without requesting a frame.
1567        // Charge input work only while a frame is pending, otherwise the next
1568        // redraw inherits an arbitrarily large, unrelated "frame time".
1569        if !is_redraw
1570            && !is_close
1571            && self.runtime.needs_render(window_id)?
1572            && let Some(window) = self.windows.get_mut(&window_id)
1573        {
1574            window.pending_event_time_ms += event_time_ms;
1575            window.last_non_redraw_event_at_ms = Some(event_arrived_at_ms);
1576        }
1577
1578        if !is_redraw && !is_close {
1579            self.request_redraw_if_needed(window_id)?;
1580        }
1581
1582        // Render only in response to `RedrawRequested`. Every other event (resize, scale
1583        // change, input) marks the schedule and asks winit for a redraw via
1584        // `request_redraw_if_needed` above; winit then delivers `RedrawRequested` and we render
1585        // here. Rendering synchronously inside the originating event instead clears the frame
1586        // schedule, so the redraw winit subsequently delivers finds `needs_render() == false`
1587        // and becomes a no-op — and a synchronous present issued inside a `Resized` callback is
1588        // not reliably composited (notably during the Windows modal resize loop), leaving the
1589        // window stale until an unrelated event repaints it.
1590        if is_redraw {
1591            if let Some(window) = self.windows.get_mut(&window_id) {
1592                window.redraw_requested = false;
1593            }
1594
1595            self.render_window_if_needed(window_id, event_time_ms)?;
1596            self.service_debug_captures(window_id)?;
1597            // Chain continuous presentation from WM_PAINT/RedrawRequested;
1598            // AboutToWait alone cannot sustain it during an OS modal loop.
1599            self.request_redraw_if_needed(window_id)?;
1600        }
1601
1602        if is_close {
1603            if let Some(window) = self.windows.get_mut(&window_id) {
1604                release_host_cursor(window);
1605            }
1606            self.runtime.remove_window(window_id)?;
1607            crate::clear_window_performance(window_id);
1608            self.sync_windows(event_loop)?;
1609            self.sync_extensions()?;
1610        }
1611
1612        self.exit_if_windows_closed(event_loop);
1613
1614        Ok(handled)
1615    }
1616
1617    fn sync_window_cursor(&mut self, window_id: WindowId) -> Result<()> {
1618        let desired = self.runtime.window_cursor_state(window_id)?;
1619        let Some(window) = self.windows.get_mut(&window_id) else {
1620            return Ok(());
1621        };
1622        if window.applied_cursor_revision == desired.revision {
1623            return Ok(());
1624        }
1625
1626        let requested_grab = if window.focused {
1627            desired.grab_mode
1628        } else {
1629            CursorGrabMode::None
1630        };
1631        window.applied_cursor_grab = apply_host_cursor_grab(window.window.as_ref(), requested_grab);
1632        window
1633            .window
1634            .set_cursor_visible(desired.visible || !window.focused);
1635        window.applied_cursor_revision = desired.revision;
1636        Ok(())
1637    }
1638
1639    /// Make the captures the app asked for from the frame just presented,
1640    /// then wake the widgets waiting for them.
1641    fn service_debug_captures(&mut self, window_id: WindowId) -> Result<()> {
1642        for token in crate::service_window_debug_captures(&mut self.renderer, window_id) {
1643            self.runtime.wake_async(window_id, token)?;
1644        }
1645        Ok(())
1646    }
1647
1648    fn render_window_if_needed(&mut self, window_id: WindowId, event_time_ms: f64) -> Result<()> {
1649        // Windows can still deliver redraws and async wakes while minimized.
1650        // Preserve pending runtime work until there is a drawable native surface.
1651        if self.windows.get(&window_id).is_none_or(|host| {
1652            let size = host.window.inner_size();
1653            host.occluded
1654                || host.window.is_minimized() == Some(true)
1655                || size.width == 0
1656                || size.height == 0
1657        }) {
1658            return Ok(());
1659        }
1660        let present_pending = self
1661            .windows
1662            .get(&window_id)
1663            .is_some_and(|window| window.present_pending);
1664        if !self.runtime.needs_render(window_id)? && !present_pending {
1665            return Ok(());
1666        }
1667        if let Some(window) = self.windows.get_mut(&window_id) {
1668            window.present_pending = false;
1669        }
1670
1671        self.update_clock();
1672        self.runtime.tick(self.frame_clock);
1673
1674        let render_started_at_ms = self.current_time_ms();
1675        let mut presentation_latency = PresentationLatencyDiagnostics::default();
1676        if let Some(window) = self.windows.get(&window_id) {
1677            presentation_latency = PresentationLatencyDiagnostics::new(
1678                window
1679                    .last_non_redraw_event_at_ms
1680                    .map(|timestamp| (render_started_at_ms - timestamp).max(0.0))
1681                    .unwrap_or(0.0),
1682                0.0,
1683                window
1684                    .redraw_requested_at_ms
1685                    .map(|timestamp| (render_started_at_ms - timestamp).max(0.0))
1686                    .unwrap_or(0.0),
1687            );
1688        }
1689
1690        if self
1691            .windows
1692            .get(&window_id)
1693            .is_some_and(|window| window.display_capabilities_dirty)
1694        {
1695            self.refresh_window_display_capabilities(window_id)?;
1696            if let Some(window) = self.windows.get_mut(&window_id) {
1697                window.display_capabilities_dirty = false;
1698            }
1699        }
1700        let PresentedFrame {
1701            output,
1702            runtime_time_ms,
1703            renderer_time_ms,
1704            presented_at,
1705        } = present_window_frame(&mut self.runtime, &mut self.renderer, window_id)?;
1706        // A render pass can rebuild the widget graph after reactive state
1707        // removed the cursor owner. Apply the runtime's resulting reset even
1708        // when no further input event arrives.
1709        self.sync_window_cursor(window_id)?;
1710        let semantics = output.semantics.clone();
1711        let presented_at = (!self.extensions.is_empty()).then_some(presented_at);
1712        let presented_at_ms = self.current_time_ms();
1713        if let Some(window) = self.windows.get(&window_id) {
1714            presentation_latency.event_to_present_ms = window
1715                .last_non_redraw_event_at_ms
1716                .map(|timestamp| (presented_at_ms - timestamp).max(0.0))
1717                .unwrap_or(0.0);
1718        }
1719
1720        let mut frame_index = 0;
1721        let mut pending_event_time_ms = 0.0;
1722
1723        if let Some(window) = self.windows.get_mut(&window_id) {
1724            frame_index = window.frame_index + 1;
1725            pending_event_time_ms = std::mem::take(&mut window.pending_event_time_ms);
1726            window.frame_index = frame_index;
1727
1728            if window.title != output.title {
1729                window.title = output.title.clone();
1730                window.window.set_title(&output.title);
1731            }
1732
1733            #[cfg(target_os = "windows")]
1734            {
1735                let scale_factor = window.scale_factor;
1736                let WindowState {
1737                    accesskit_adapter,
1738                    accesskit_snapshot,
1739                    ..
1740                } = window;
1741                accesskit_adapter.update_if_active(|| {
1742                    let snapshot = build_accesskit_snapshot(
1743                        window_id,
1744                        scale_factor,
1745                        &output.title,
1746                        &semantics,
1747                    );
1748                    let update = snapshot.full_update();
1749                    *accesskit_snapshot = snapshot;
1750                    update
1751                });
1752            }
1753
1754            window.accessibility.update(window_id, semantics);
1755            window.last_non_redraw_event_at_ms = None;
1756            window.redraw_requested_at_ms = None;
1757
1758            apply_ime_composition_rect(
1759                window.window.as_ref(),
1760                &mut window.ime_allowed,
1761                output.ime_composition_rect,
1762            );
1763        }
1764
1765        crate::publish_frame_performance(
1766            window_id,
1767            frame_index,
1768            pending_event_time_ms,
1769            event_time_ms,
1770            runtime_time_ms,
1771            presentation_latency,
1772            &output,
1773            &self.renderer,
1774            renderer_time_ms,
1775        );
1776
1777        if let Some(presented_at) = presented_at {
1778            let commands = self.runtime.command_sender();
1779            for extension in &mut self.extensions {
1780                extension.frame_presented(
1781                    DesktopExtensionContext {
1782                        runtime: &self.runtime,
1783                        renderer: &self.renderer,
1784                        windows: &self.windows,
1785                        commands: &commands,
1786                    },
1787                    DesktopFramePresented {
1788                        window_id,
1789                        frame_index,
1790                        presented_at,
1791                        runtime_duration: Duration::from_secs_f64(runtime_time_ms / 1000.0),
1792                    },
1793                )?;
1794            }
1795        }
1796
1797        #[cfg(target_arch = "wasm32")]
1798        if let Some(window) = self.windows.get(&window_id) {
1799            let performance = window_performance_snapshot(window_id);
1800            crate::web_interop::publish_snapshot(
1801                window_id,
1802                frame_index,
1803                window.scale_factor,
1804                output.frame.viewport,
1805                &output.semantics,
1806                performance.as_ref(),
1807            );
1808        }
1809
1810        let bootstrap_redraw_at_ms = self.current_time_ms();
1811        if let Some(window) = self.windows.get_mut(&window_id)
1812            && window.awaiting_performance_bootstrap
1813        {
1814            window.awaiting_performance_bootstrap = false;
1815            if !window.redraw_requested {
1816                window.redraw_requested = true;
1817                window.redraw_requested_at_ms = Some(bootstrap_redraw_at_ms);
1818                window.window.request_redraw();
1819            }
1820        }
1821
1822        Ok(())
1823    }
1824
1825    fn handle_window_event(
1826        &mut self,
1827        event_loop: &ActiveEventLoop,
1828        host_id: HostWindowId,
1829        event: WinitWindowEvent,
1830    ) -> Result<()> {
1831        let Some(window_id) = self.host_to_runtime.get(&host_id).copied() else {
1832            return Ok(());
1833        };
1834
1835        #[cfg(target_os = "windows")]
1836        if let Some(window) = self.windows.get_mut(&window_id) {
1837            // AccessKit's winit adapter must see each native window event first so
1838            // focus, geometry, and lifecycle state stay synchronized with UIA.
1839            window
1840                .accesskit_adapter
1841                .process_event(window.window.as_ref(), &event);
1842        }
1843
1844        if let Some(file_event) = map_external_file_window_event(&event) {
1845            return self.process_event(event_loop, window_id, Event::Window(file_event));
1846        }
1847
1848        match event {
1849            WinitWindowEvent::CloseRequested => self.process_event(
1850                event_loop,
1851                window_id,
1852                Event::Window(WindowEvent::CloseRequested),
1853            ),
1854            // A minimized Windows surface reports zero dimensions. Keep the
1855            // last valid layout and process the restoring nonzero resize.
1856            WinitWindowEvent::Resized(size) if size.width == 0 || size.height == 0 => Ok(()),
1857            WinitWindowEvent::Resized(size) => self.process_event(
1858                event_loop,
1859                window_id,
1860                Event::Window(WindowEvent::Resized(
1861                    self.windows
1862                        .get(&window_id)
1863                        .map(|window| physical_size_to_logical_size(size, window.scale_factor))
1864                        .unwrap_or_else(|| physical_size_to_logical_size(size, 1.0)),
1865                )),
1866            ),
1867            WinitWindowEvent::Moved(position) => {
1868                // The window may now be on a monitor with another refresh rate.
1869                if let Some(window) = self.windows.get_mut(&window_id) {
1870                    window.refresh_interval = monitor_refresh_interval(&window.window);
1871                }
1872                self.process_event(
1873                    event_loop,
1874                    window_id,
1875                    Event::Window(WindowEvent::Moved(Point::new(
1876                        position.x as f32,
1877                        position.y as f32,
1878                    ))),
1879                )
1880            }
1881            WinitWindowEvent::ScaleFactorChanged { scale_factor, .. } => {
1882                let suggested_size = self.windows.get_mut(&window_id).map(|window| {
1883                    window.scale_factor = scale_factor;
1884                    window.display_capabilities_dirty = true;
1885                    window.refresh_interval = monitor_refresh_interval(&window.window);
1886                    physical_size_to_logical_size(window.window.inner_size(), scale_factor)
1887                });
1888                self.process_event(
1889                    event_loop,
1890                    window_id,
1891                    Event::Window(WindowEvent::ScaleFactorChanged {
1892                        scale_factor,
1893                        raw_dpi: None,
1894                        suggested_size,
1895                    }),
1896                )
1897            }
1898            WinitWindowEvent::Focused(focused) => {
1899                if focused {
1900                    // The setting may have changed while another app had focus.
1901                    crate::motion_preference::sync_system_motion_preference();
1902                }
1903                if let Some(window) = self.windows.get_mut(&window_id) {
1904                    window.focused = focused;
1905                    if !focused {
1906                        window.android_back_down_seen = false;
1907                        release_host_cursor(window);
1908                    }
1909                }
1910                self.process_event(
1911                    event_loop,
1912                    window_id,
1913                    Event::Window(WindowEvent::Focused(focused)),
1914                )
1915            }
1916            WinitWindowEvent::Occluded(occluded) => {
1917                if let Some(window) = self.windows.get_mut(&window_id) {
1918                    window.occluded = occluded;
1919                }
1920                self.process_event(
1921                    event_loop,
1922                    window_id,
1923                    Event::Window(WindowEvent::Occluded(occluded)),
1924                )
1925            }
1926            WinitWindowEvent::RedrawRequested => self.process_event(
1927                event_loop,
1928                window_id,
1929                Event::Window(WindowEvent::RedrawRequested),
1930            ),
1931            WinitWindowEvent::ModifiersChanged(modifiers) => {
1932                if let Some(window) = self.windows.get_mut(&window_id) {
1933                    window.pointer.modifiers = modifiers_state_to_modifiers(modifiers.state());
1934                }
1935                Ok(())
1936            }
1937            WinitWindowEvent::CursorMoved { position, .. } => {
1938                let event = if let Some(window) = self.windows.get_mut(&window_id) {
1939                    let next_position =
1940                        physical_position_to_logical_point(position, window.scale_factor);
1941                    let delta = Vector::new(
1942                        next_position.x - window.pointer.position.x,
1943                        next_position.y - window.pointer.position.y,
1944                    );
1945                    window.pointer.position = next_position;
1946                    Event::Pointer(PointerEvent {
1947                        pointer_id: 1,
1948                        kind: PointerEventKind::Move,
1949                        position: next_position,
1950                        delta,
1951                        scroll_delta: None,
1952                        button: None,
1953                        buttons: window.pointer.buttons,
1954                        modifiers: window.pointer.modifiers,
1955                        pointer_kind: PointerKind::Mouse,
1956                        is_primary: true,
1957                    })
1958                } else {
1959                    return Ok(());
1960                };
1961
1962                self.process_event(event_loop, window_id, event)
1963            }
1964            WinitWindowEvent::CursorEntered { .. } => {
1965                let event = if let Some(window) = self.windows.get(&window_id) {
1966                    Event::Pointer(PointerEvent {
1967                        pointer_id: 1,
1968                        kind: PointerEventKind::Enter,
1969                        position: window.pointer.position,
1970                        delta: Vector::ZERO,
1971                        scroll_delta: None,
1972                        button: None,
1973                        buttons: window.pointer.buttons,
1974                        modifiers: window.pointer.modifiers,
1975                        pointer_kind: PointerKind::Mouse,
1976                        is_primary: true,
1977                    })
1978                } else {
1979                    return Ok(());
1980                };
1981
1982                self.process_event(event_loop, window_id, event)
1983            }
1984            WinitWindowEvent::CursorLeft { .. } => {
1985                let event = if let Some(window) = self.windows.get(&window_id) {
1986                    Event::Pointer(PointerEvent {
1987                        pointer_id: 1,
1988                        kind: PointerEventKind::Leave,
1989                        position: window.pointer.position,
1990                        delta: Vector::ZERO,
1991                        scroll_delta: None,
1992                        button: None,
1993                        buttons: window.pointer.buttons,
1994                        modifiers: window.pointer.modifiers,
1995                        pointer_kind: PointerKind::Mouse,
1996                        is_primary: true,
1997                    })
1998                } else {
1999                    return Ok(());
2000                };
2001
2002                self.process_event(event_loop, window_id, event)
2003            }
2004            WinitWindowEvent::MouseInput { state, button, .. } => {
2005                let event = if let Some(window) = self.windows.get_mut(&window_id) {
2006                    let Some(pointer_button) = map_mouse_button(button) else {
2007                        return Ok(());
2008                    };
2009
2010                    match state {
2011                        ElementState::Pressed => window.pointer.buttons.insert(pointer_button),
2012                        ElementState::Released => {
2013                            window.pointer.buttons =
2014                                remove_pointer_button(window.pointer.buttons, pointer_button);
2015                        }
2016                    }
2017
2018                    Event::Pointer(PointerEvent {
2019                        pointer_id: 1,
2020                        kind: match state {
2021                            ElementState::Pressed => PointerEventKind::Down,
2022                            ElementState::Released => PointerEventKind::Up,
2023                        },
2024                        position: window.pointer.position,
2025                        delta: Vector::ZERO,
2026                        scroll_delta: None,
2027                        button: Some(pointer_button),
2028                        buttons: window.pointer.buttons,
2029                        modifiers: window.pointer.modifiers,
2030                        pointer_kind: PointerKind::Mouse,
2031                        is_primary: true,
2032                    })
2033                } else {
2034                    return Ok(());
2035                };
2036
2037                self.process_event(event_loop, window_id, event)
2038            }
2039            WinitWindowEvent::MouseWheel { delta, .. } => {
2040                let event = if let Some(window) = self.windows.get(&window_id) {
2041                    Event::Pointer(PointerEvent {
2042                        pointer_id: 1,
2043                        kind: PointerEventKind::Scroll,
2044                        position: window.pointer.position,
2045                        delta: Vector::ZERO,
2046                        scroll_delta: Some(match delta {
2047                            MouseScrollDelta::LineDelta(x, y) => {
2048                                ScrollDelta::Lines(Vector::new(x, y))
2049                            }
2050                            MouseScrollDelta::PixelDelta(position) => ScrollDelta::Pixels(
2051                                physical_position_to_logical_vector(position, window.scale_factor),
2052                            ),
2053                        }),
2054                        button: None,
2055                        buttons: window.pointer.buttons,
2056                        modifiers: window.pointer.modifiers,
2057                        pointer_kind: PointerKind::Mouse,
2058                        is_primary: true,
2059                    })
2060                } else {
2061                    return Ok(());
2062                };
2063
2064                self.process_event(event_loop, window_id, event)
2065            }
2066            WinitWindowEvent::Touch(touch) => {
2067                let event = if let Some(window) = self.windows.get_mut(&window_id) {
2068                    let position =
2069                        physical_position_to_logical_point(touch.location, window.scale_factor);
2070                    let previous = window
2071                        .touch_points
2072                        .get(&touch.id)
2073                        .copied()
2074                        .unwrap_or(position);
2075                    let kind = match touch.phase {
2076                        TouchPhase::Started => PointerEventKind::Down,
2077                        TouchPhase::Moved => PointerEventKind::Move,
2078                        TouchPhase::Ended => PointerEventKind::Up,
2079                        TouchPhase::Cancelled => PointerEventKind::Cancel,
2080                    };
2081                    let was_primary = window
2082                        .touch_points
2083                        .keys()
2084                        .min()
2085                        .copied()
2086                        .map(|id| id == touch.id)
2087                        .unwrap_or(true);
2088                    match touch.phase {
2089                        TouchPhase::Started | TouchPhase::Moved => {
2090                            window.touch_points.insert(touch.id, position);
2091                        }
2092                        TouchPhase::Ended | TouchPhase::Cancelled => {
2093                            window.touch_points.remove(&touch.id);
2094                        }
2095                    }
2096                    let buttons = match touch.phase {
2097                        TouchPhase::Started | TouchPhase::Moved => PointerButtons::new(1),
2098                        TouchPhase::Ended | TouchPhase::Cancelled => PointerButtons::NONE,
2099                    };
2100                    Event::Pointer(PointerEvent {
2101                        pointer_id: touch.id,
2102                        kind,
2103                        position,
2104                        delta: Vector::new(position.x - previous.x, position.y - previous.y),
2105                        scroll_delta: None,
2106                        button: match touch.phase {
2107                            TouchPhase::Started | TouchPhase::Ended => Some(PointerButton::Primary),
2108                            TouchPhase::Moved | TouchPhase::Cancelled => None,
2109                        },
2110                        buttons,
2111                        modifiers: window.pointer.modifiers,
2112                        pointer_kind: PointerKind::Touch,
2113                        is_primary: was_primary,
2114                    })
2115                } else {
2116                    return Ok(());
2117                };
2118
2119                self.process_event(event_loop, window_id, event)
2120            }
2121            WinitWindowEvent::KeyboardInput { event, .. } => {
2122                let (effective_state, is_android_back) = if cfg!(target_os = "android") {
2123                    let down_seen = self
2124                        .windows
2125                        .get_mut(&window_id)
2126                        .map(|window| &mut window.android_back_down_seen);
2127                    down_seen.map_or((event.state, false), |down_seen| {
2128                        normalize_android_back_event(
2129                            &event.logical_key,
2130                            event.state,
2131                            event.repeat,
2132                            down_seen,
2133                        )
2134                    })
2135                } else {
2136                    (event.state, false)
2137                };
2138                let modifiers = self
2139                    .windows
2140                    .get(&window_id)
2141                    .map(|window| window.pointer.modifiers)
2142                    .unwrap_or(Modifiers::NONE);
2143                let keyboard_event = KeyboardEvent {
2144                    key: logical_key_to_string(&event.logical_key),
2145                    code: physical_key_to_string(&event.physical_key),
2146                    text: event.text.as_ref().map(|text| text.to_string()),
2147                    state: match effective_state {
2148                        ElementState::Pressed => KeyState::Pressed,
2149                        ElementState::Released => KeyState::Released,
2150                    },
2151                    modifiers,
2152                    repeat: event.repeat,
2153                    is_composing: false,
2154                };
2155                let handled = self.process_event_with_outcome(
2156                    event_loop,
2157                    window_id,
2158                    Event::Keyboard(keyboard_event),
2159                )?;
2160                if is_android_back && !handled {
2161                    self.process_event(
2162                        event_loop,
2163                        window_id,
2164                        Event::Window(WindowEvent::CloseRequested),
2165                    )?;
2166                }
2167                Ok(())
2168            }
2169            WinitWindowEvent::Ime(ime) => {
2170                if let Some(ime_event) = map_ime_event(ime) {
2171                    self.process_event(event_loop, window_id, Event::Ime(ime_event))
2172                } else {
2173                    Ok(())
2174                }
2175            }
2176            _ => Ok(()),
2177        }
2178    }
2179
2180    fn handle_device_event(
2181        &mut self,
2182        event_loop: &ActiveEventLoop,
2183        event: DeviceEvent,
2184    ) -> Result<()> {
2185        let DeviceEvent::MouseMotion { delta } = event else {
2186            return Ok(());
2187        };
2188        let Some((window_id, modifiers)) = self.windows.iter().find_map(|(&window_id, window)| {
2189            (window.focused && window.applied_cursor_grab != CursorGrabMode::None)
2190                .then_some((window_id, window.pointer.modifiers))
2191        }) else {
2192            return Ok(());
2193        };
2194        let delta = raw_mouse_motion_to_vector(delta);
2195        self.process_event(
2196            event_loop,
2197            window_id,
2198            Event::RawMouseMotion(RawMouseMotionEvent { delta, modifiers }),
2199        )
2200    }
2201
2202    #[cfg(target_os = "windows")]
2203    fn handle_accesskit_event(
2204        &mut self,
2205        event_loop: &ActiveEventLoop,
2206        event: AccessKitEvent,
2207    ) -> Result<()> {
2208        let Some(window_id) = self.host_to_runtime.get(&event.window_id).copied() else {
2209            return Ok(());
2210        };
2211
2212        match event.window_event {
2213            AccessKitWindowEvent::InitialTreeRequested => {
2214                let Some(window) = self.windows.get_mut(&window_id) else {
2215                    return Ok(());
2216                };
2217                let snapshot = build_accesskit_snapshot(
2218                    window_id,
2219                    window.scale_factor,
2220                    &window.title,
2221                    window
2222                        .accessibility
2223                        .snapshot()
2224                        .map(|snapshot| snapshot.nodes.as_slice())
2225                        .unwrap_or(&[]),
2226                );
2227                let update = snapshot.full_update();
2228                window.accesskit_snapshot = snapshot;
2229                let WindowState {
2230                    accesskit_adapter, ..
2231                } = window;
2232                accesskit_adapter.update_if_active(|| update);
2233                Ok(())
2234            }
2235            AccessKitWindowEvent::ActionRequested(request) => {
2236                let mapped = self
2237                    .windows
2238                    .get(&window_id)
2239                    .and_then(|window| window.accesskit_snapshot.map_action(&request));
2240                let Some((target, action)) = mapped else {
2241                    return Ok(());
2242                };
2243
2244                // Accessibility callbacks arrive through the event-loop proxy, so
2245                // widget state continues to be mutated exclusively on the UI thread.
2246                self.update_clock();
2247                self.runtime.tick(self.frame_clock);
2248                let _handled = self
2249                    .runtime
2250                    .handle_semantics_action(window_id, target, action)?;
2251                self.drive_runtime(event_loop)
2252            }
2253            AccessKitWindowEvent::AccessibilityDeactivated => Ok(()),
2254        }
2255    }
2256
2257    fn handle_error(&mut self, event_loop: &ActiveEventLoop, error: Error) {
2258        self.last_error = Some(error);
2259        event_loop.exit();
2260    }
2261
2262    fn drive_automation(&mut self, event_loop: &ActiveEventLoop) -> Result<()> {
2263        let now = Instant::now();
2264        let mut state = match self.automation.take() {
2265            Some(state) => state,
2266            None => return Ok(()),
2267        };
2268
2269        if state.shutdown_requested {
2270            self.automation = Some(state);
2271            return Ok(());
2272        }
2273
2274        if state.started_at.is_none() && now >= state.armed_at + state.config.startup_timeout {
2275            println!(
2276                "[desktop automation:{}] timed out waiting for target {:?} named {:?}",
2277                state.config.label, state.config.target_role, state.config.target_name
2278            );
2279            state.shutdown_requested = true;
2280            self.automation = Some(state);
2281            return Ok(());
2282        }
2283
2284        if let Some((window_id, target_point)) = self.find_automation_target(&state) {
2285            if state.started_at.is_none() {
2286                state.started_at = Some(now);
2287                state.last_report_at = Some(now);
2288                state.last_report_frame_index = window_performance_snapshot(window_id)
2289                    .map(|snapshot| snapshot.frame_index)
2290                    .unwrap_or(0);
2291                state.target_window_id = Some(window_id);
2292                println!(
2293                    "[desktop automation:{}] started on window {}",
2294                    state.config.label,
2295                    window_id.get()
2296                );
2297                self.process_event(
2298                    event_loop,
2299                    window_id,
2300                    Event::Window(WindowEvent::Focused(true)),
2301                )?;
2302            }
2303
2304            if !state.pointer_primed {
2305                self.inject_pointer_move(event_loop, window_id, target_point, true)?;
2306                state.pointer_primed = true;
2307            }
2308
2309            self.report_automation_progress(&mut state, false);
2310
2311            let started_at = state.started_at.expect("automation should have started");
2312            if now >= started_at + state.config.duration {
2313                self.report_automation_progress(&mut state, true);
2314                println!("[desktop automation:{}] completed", state.config.label);
2315                state.shutdown_requested = true;
2316                self.automation = Some(state);
2317                return Ok(());
2318            }
2319
2320            if now >= state.next_step_at {
2321                self.inject_automation_action(
2322                    event_loop,
2323                    window_id,
2324                    target_point,
2325                    &state.config.action,
2326                )?;
2327                state.next_step_at = now + state.config.step_interval;
2328            }
2329        }
2330
2331        self.automation = Some(state);
2332        Ok(())
2333    }
2334
2335    fn find_automation_target(&self, state: &DesktopAutomationState) -> Option<(WindowId, Point)> {
2336        self.windows.iter().find_map(|(window_id, window)| {
2337            let snapshot = window.accessibility.snapshot()?;
2338            let node = snapshot.nodes.iter().find(|node| {
2339                node.role == state.config.target_role
2340                    && node.name.as_deref() == Some(state.config.target_name.as_str())
2341            })?;
2342            let point = if node.role == SemanticsRole::ScrollView {
2343                Point::new(
2344                    node.bounds.x() + node.bounds.width().min(48.0),
2345                    node.bounds.y() + node.bounds.height() * 0.5,
2346                )
2347            } else {
2348                Point::new(
2349                    node.bounds.x() + node.bounds.width() * 0.5,
2350                    node.bounds.y() + node.bounds.height() * 0.5,
2351                )
2352            };
2353            Some((*window_id, point))
2354        })
2355    }
2356
2357    fn report_automation_progress(&self, state: &mut DesktopAutomationState, force: bool) {
2358        let Some(window_id) = state.target_window_id else {
2359            return;
2360        };
2361        let now = Instant::now();
2362        let Some(last_report_at) = state.last_report_at else {
2363            state.last_report_at = Some(now);
2364            return;
2365        };
2366        if !force && now < last_report_at + state.config.report_interval {
2367            return;
2368        }
2369        let Some(snapshot) = window_performance_snapshot(window_id) else {
2370            state.last_report_at = Some(now);
2371            return;
2372        };
2373        let elapsed = (now - last_report_at).as_secs_f64().max(f64::EPSILON);
2374        let frame_delta = snapshot
2375            .frame_index
2376            .saturating_sub(state.last_report_frame_index);
2377        let observed_fps = frame_delta as f64 / elapsed;
2378        Self::print_automation_snapshot(&state.config.label, observed_fps, &snapshot);
2379        state.last_report_at = Some(now);
2380        state.last_report_frame_index = snapshot.frame_index;
2381    }
2382
2383    fn print_automation_snapshot(
2384        label: &str,
2385        observed_fps: f64,
2386        snapshot: &WindowPerformanceSnapshot,
2387    ) {
2388        let slowest_phase = snapshot
2389            .slowest_phase()
2390            .map(|sample| format!("{}:{:.3}ms", sample.phase.label(), sample.duration_ms))
2391            .unwrap_or_else(|| "n/a".to_string());
2392        let phase_breakdown = if snapshot.phase_timings.is_empty() {
2393            "n/a".to_string()
2394        } else {
2395            snapshot
2396                .phase_timings
2397                .iter()
2398                .map(|sample| format!("{}={:.3}", sample.phase.label(), sample.duration_ms))
2399                .collect::<Vec<_>>()
2400                .join(",")
2401        };
2402        let renderer_breakdown = format!(
2403            "comp={:.3},traverse={:.3},batch={:.3},upload={:.3},encode={:.3},submit={:.3},res={:.3},bind={:.3},atlas_miss={}({:.3}ms)",
2404            snapshot.renderer_submission.composition_time_us as f64 / 1000.0,
2405            snapshot
2406                .renderer_submission
2407                .retained_scene_traversal_time_us as f64
2408                / 1000.0,
2409            snapshot.renderer_submission.batch_prepare_time_us as f64 / 1000.0,
2410            snapshot.renderer_submission.gpu_upload_time_us as f64 / 1000.0,
2411            snapshot.renderer_submission.pass_encode_time_us as f64 / 1000.0,
2412            snapshot.renderer_submission.queue_submit_time_us as f64 / 1000.0,
2413            snapshot.renderer_submission.resource_collection_time_us as f64 / 1000.0,
2414            snapshot.renderer_submission.bind_group_prepare_time_us as f64 / 1000.0,
2415            snapshot.renderer_submission.text_atlas_miss_count,
2416            snapshot.renderer_submission.text_atlas_miss_time_us as f64 / 1000.0,
2417        );
2418        let hotspot = snapshot
2419            .retained_packet_hotspot
2420            .as_ref()
2421            .map(|hotspot| {
2422                format!(
2423                    "widget={:?},total={:.3}ms,cmds={},text={},paths={},rects={}",
2424                    hotspot.owner_widget_id,
2425                    hotspot.total_time_us as f64 / 1000.0,
2426                    hotspot.command_count,
2427                    hotspot.text_command_count,
2428                    hotspot.path_command_count,
2429                    hotspot.rect_command_count,
2430                )
2431            })
2432            .unwrap_or_else(|| "n/a".to_string());
2433        println!(
2434            "[desktop automation:{label}] observed_fps={observed_fps:.1} frame={} total={:.3}ms slowest={} dirty={:.1}% cmds={} acq={:.3}ms pres={:.3}ms build={:.3}ms state={:.3}ms layers={} draws={} phases=[{}] renderer=[{}] hotspot=[{}]",
2435            snapshot.frame_index,
2436            snapshot.total_time_ms,
2437            slowest_phase,
2438            snapshot.scene.dirty_coverage,
2439            snapshot.scene.command_count,
2440            snapshot.renderer_submission.surface_acquire_time_us as f64 / 1000.0,
2441            snapshot.renderer_submission.surface_present_time_us as f64 / 1000.0,
2442            snapshot.renderer_submission.retained_packet_build_time_us as f64 / 1000.0,
2443            snapshot.renderer_submission.retained_state_update_time_us as f64 / 1000.0,
2444            snapshot.renderer_submission.visible_layer_count,
2445            snapshot.renderer_submission.draw_count,
2446            phase_breakdown,
2447            renderer_breakdown,
2448            hotspot,
2449        );
2450    }
2451
2452    #[cfg(target_arch = "wasm32")]
2453    fn process_web_interop_commands(&mut self, event_loop: &ActiveEventLoop) -> Result<()> {
2454        for command in crate::web_interop::drain_commands() {
2455            match command {
2456                crate::web_interop::WebInteropCommand::Click { target } => {
2457                    if let Some((window_id, node)) = self.find_semantics_node(&target) {
2458                        if let Some(action) = web_click_semantics_action(&node) {
2459                            let _ = self
2460                                .runtime
2461                                .handle_semantics_action(window_id, node.id, action)?;
2462                        } else {
2463                            self.inject_pointer_click(event_loop, window_id, center(node.bounds))?;
2464                        }
2465                    }
2466                }
2467                crate::web_interop::WebInteropCommand::Scroll {
2468                    target,
2469                    delta_x,
2470                    delta_y,
2471                } => {
2472                    if let Some((window_id, point)) = self.find_semantics_node_point(&target) {
2473                        self.inject_pointer_scroll(
2474                            event_loop,
2475                            window_id,
2476                            point,
2477                            Vector::new(delta_x, delta_y),
2478                        )?;
2479                    }
2480                }
2481                crate::web_interop::WebInteropCommand::Key { target, key } => {
2482                    if let Some((window_id, point)) = self.find_semantics_node_point(&target) {
2483                        self.inject_pointer_click(event_loop, window_id, point)?;
2484                        self.inject_key(event_loop, window_id, key)?;
2485                    }
2486                }
2487                crate::web_interop::WebInteropCommand::Text { target, text } => {
2488                    if let Some((window_id, point)) = self.find_semantics_node_point(&target) {
2489                        self.inject_pointer_click(event_loop, window_id, point)?;
2490                        self.inject_text(event_loop, window_id, text)?;
2491                    }
2492                }
2493            }
2494        }
2495
2496        Ok(())
2497    }
2498
2499    #[cfg(target_arch = "wasm32")]
2500    fn find_semantics_node(
2501        &self,
2502        target: &crate::web_interop::WebInteropTarget,
2503    ) -> Option<(WindowId, sui_core::SemanticsNode)> {
2504        self.windows.iter().find_map(|(window_id, window)| {
2505            let snapshot = window.accessibility.snapshot()?;
2506            let node = target
2507                .widget_id
2508                .and_then(|widget_id| snapshot.nodes.iter().find(|node| node.id == widget_id))
2509                .or_else(|| {
2510                    snapshot.nodes.iter().find(|node| {
2511                        target.role.as_deref().is_none_or(|role| {
2512                            format!("{:?}", node.role).eq_ignore_ascii_case(role)
2513                        }) && target
2514                            .name
2515                            .as_deref()
2516                            .is_none_or(|name| node.name.as_deref() == Some(name))
2517                    })
2518                })?;
2519            Some((*window_id, node.clone()))
2520        })
2521    }
2522
2523    #[cfg(target_arch = "wasm32")]
2524    fn find_semantics_node_point(
2525        &self,
2526        target: &crate::web_interop::WebInteropTarget,
2527    ) -> Option<(WindowId, Point)> {
2528        self.find_semantics_node(target)
2529            .map(|(window_id, node)| (window_id, center(node.bounds)))
2530    }
2531
2532    #[cfg(target_arch = "wasm32")]
2533    fn inject_pointer_click(
2534        &mut self,
2535        event_loop: &ActiveEventLoop,
2536        window_id: WindowId,
2537        point: Point,
2538    ) -> Result<()> {
2539        self.inject_pointer_move(event_loop, window_id, point, false)?;
2540        let modifiers = self
2541            .windows
2542            .get(&window_id)
2543            .map(|window| window.pointer.modifiers)
2544            .ok_or_else(|| Error::new(format!("missing window {}", window_id.get())))?;
2545
2546        let down_buttons = {
2547            let window = self
2548                .windows
2549                .get_mut(&window_id)
2550                .ok_or_else(|| Error::new(format!("missing window {}", window_id.get())))?;
2551            window.pointer.buttons.insert(PointerButton::Primary);
2552            window.pointer.buttons
2553        };
2554        self.process_event(
2555            event_loop,
2556            window_id,
2557            Event::Pointer(PointerEvent {
2558                pointer_id: 1,
2559                kind: PointerEventKind::Down,
2560                position: point,
2561                delta: Vector::ZERO,
2562                scroll_delta: None,
2563                button: Some(PointerButton::Primary),
2564                buttons: down_buttons,
2565                modifiers,
2566                pointer_kind: PointerKind::Mouse,
2567                is_primary: true,
2568            }),
2569        )?;
2570
2571        let up_buttons = {
2572            let window = self
2573                .windows
2574                .get_mut(&window_id)
2575                .ok_or_else(|| Error::new(format!("missing window {}", window_id.get())))?;
2576            window.pointer.buttons =
2577                remove_pointer_button(window.pointer.buttons, PointerButton::Primary);
2578            window.pointer.buttons
2579        };
2580        self.process_event(
2581            event_loop,
2582            window_id,
2583            Event::Pointer(PointerEvent {
2584                pointer_id: 1,
2585                kind: PointerEventKind::Up,
2586                position: point,
2587                delta: Vector::ZERO,
2588                scroll_delta: None,
2589                button: Some(PointerButton::Primary),
2590                buttons: up_buttons,
2591                modifiers,
2592                pointer_kind: PointerKind::Mouse,
2593                is_primary: true,
2594            }),
2595        )
2596    }
2597
2598    #[cfg(target_arch = "wasm32")]
2599    fn inject_pointer_scroll(
2600        &mut self,
2601        event_loop: &ActiveEventLoop,
2602        window_id: WindowId,
2603        point: Point,
2604        delta: Vector,
2605    ) -> Result<()> {
2606        self.inject_pointer_move(event_loop, window_id, point, false)?;
2607        let (buttons, modifiers) = self
2608            .windows
2609            .get(&window_id)
2610            .map(|window| (window.pointer.buttons, window.pointer.modifiers))
2611            .ok_or_else(|| Error::new(format!("missing window {}", window_id.get())))?;
2612        self.process_event(
2613            event_loop,
2614            window_id,
2615            Event::Pointer(PointerEvent {
2616                pointer_id: 1,
2617                kind: PointerEventKind::Scroll,
2618                position: point,
2619                delta: Vector::ZERO,
2620                scroll_delta: Some(ScrollDelta::Pixels(delta)),
2621                button: None,
2622                buttons,
2623                modifiers,
2624                pointer_kind: PointerKind::Mouse,
2625                is_primary: true,
2626            }),
2627        )
2628    }
2629
2630    #[cfg(target_arch = "wasm32")]
2631    fn inject_key(
2632        &mut self,
2633        event_loop: &ActiveEventLoop,
2634        window_id: WindowId,
2635        key: String,
2636    ) -> Result<()> {
2637        self.process_event(
2638            event_loop,
2639            window_id,
2640            Event::Keyboard(KeyboardEvent::new(key.clone(), KeyState::Pressed)),
2641        )?;
2642        self.process_event(
2643            event_loop,
2644            window_id,
2645            Event::Keyboard(KeyboardEvent::new(key, KeyState::Released)),
2646        )
2647    }
2648
2649    #[cfg(target_arch = "wasm32")]
2650    fn inject_text(
2651        &mut self,
2652        event_loop: &ActiveEventLoop,
2653        window_id: WindowId,
2654        text: String,
2655    ) -> Result<()> {
2656        self.process_event(
2657            event_loop,
2658            window_id,
2659            Event::Ime(ImeEvent::CompositionStart),
2660        )?;
2661        self.process_event(
2662            event_loop,
2663            window_id,
2664            Event::Ime(ImeEvent::CompositionUpdate {
2665                text: text.clone(),
2666                cursor_range: None,
2667            }),
2668        )?;
2669        self.process_event(
2670            event_loop,
2671            window_id,
2672            Event::Ime(ImeEvent::CompositionCommit { text }),
2673        )?;
2674        self.process_event(event_loop, window_id, Event::Ime(ImeEvent::CompositionEnd))
2675    }
2676
2677    fn inject_automation_action(
2678        &mut self,
2679        event_loop: &ActiveEventLoop,
2680        window_id: WindowId,
2681        target_point: Point,
2682        action: &DesktopAutomationAction,
2683    ) -> Result<()> {
2684        match action {
2685            DesktopAutomationAction::ScrollPixels { delta } => {
2686                self.inject_pointer_move(event_loop, window_id, target_point, false)?;
2687                let (buttons, modifiers) = self
2688                    .windows
2689                    .get(&window_id)
2690                    .map(|window| (window.pointer.buttons, window.pointer.modifiers))
2691                    .ok_or_else(|| Error::new(format!("missing window {}", window_id.get())))?;
2692                self.process_event(
2693                    event_loop,
2694                    window_id,
2695                    Event::Pointer(PointerEvent {
2696                        pointer_id: 1,
2697                        kind: PointerEventKind::Scroll,
2698                        position: target_point,
2699                        delta: Vector::ZERO,
2700                        scroll_delta: Some(ScrollDelta::Pixels(*delta)),
2701                        button: None,
2702                        buttons,
2703                        modifiers,
2704                        pointer_kind: PointerKind::Mouse,
2705                        is_primary: true,
2706                    }),
2707                )
2708            }
2709        }
2710    }
2711
2712    fn inject_pointer_move(
2713        &mut self,
2714        event_loop: &ActiveEventLoop,
2715        window_id: WindowId,
2716        position: Point,
2717        emit_enter: bool,
2718    ) -> Result<()> {
2719        let (previous, buttons, modifiers) = {
2720            let window = self
2721                .windows
2722                .get(&window_id)
2723                .ok_or_else(|| Error::new(format!("missing window {}", window_id.get())))?;
2724            (
2725                window.pointer.position,
2726                window.pointer.buttons,
2727                window.pointer.modifiers,
2728            )
2729        };
2730
2731        if emit_enter {
2732            self.process_event(
2733                event_loop,
2734                window_id,
2735                Event::Pointer(PointerEvent {
2736                    pointer_id: 1,
2737                    kind: PointerEventKind::Enter,
2738                    position,
2739                    delta: Vector::ZERO,
2740                    scroll_delta: None,
2741                    button: None,
2742                    buttons,
2743                    modifiers,
2744                    pointer_kind: PointerKind::Mouse,
2745                    is_primary: true,
2746                }),
2747            )?;
2748        }
2749
2750        if let Some(window) = self.windows.get_mut(&window_id) {
2751            window.pointer.position = position;
2752        }
2753
2754        self.process_event(
2755            event_loop,
2756            window_id,
2757            Event::Pointer(PointerEvent {
2758                pointer_id: 1,
2759                kind: PointerEventKind::Move,
2760                position,
2761                delta: Vector::new(position.x - previous.x, position.y - previous.y),
2762                scroll_delta: None,
2763                button: None,
2764                buttons,
2765                modifiers,
2766                pointer_kind: PointerKind::Mouse,
2767                is_primary: true,
2768            }),
2769        )
2770    }
2771}
2772
2773/// Background-thread signal that wakes the desktop event loop (carried as a winit user event).
2774#[derive(Debug, Clone, Copy)]
2775pub struct WakeSignal;
2776
2777/// A cheap, cloneable, `Send` handle that wakes the running desktop UI from any thread.
2778/// Pending [`wake`](Self::wake) calls are coalesced into one event-loop signal. This is a
2779/// scheduler primitive: it does not synthesize or route a widget event.
2780#[derive(Clone)]
2781pub struct Waker {
2782    proxy: EventLoopProxy<DesktopUserEvent>,
2783    pending: Arc<AtomicBool>,
2784    kind: WakeKind,
2785}
2786
2787#[derive(Debug, Clone, Copy)]
2788enum WakeKind {
2789    External,
2790    Reactive,
2791}
2792
2793impl Waker {
2794    fn new(
2795        proxy: EventLoopProxy<DesktopUserEvent>,
2796        pending: Arc<AtomicBool>,
2797        kind: WakeKind,
2798    ) -> Self {
2799        Self {
2800            proxy,
2801            pending,
2802            kind,
2803        }
2804    }
2805
2806    pub fn wake(&self) {
2807        if self
2808            .pending
2809            .compare_exchange(false, true, Ordering::AcqRel, Ordering::Acquire)
2810            .is_err()
2811        {
2812            return;
2813        }
2814        let event = match self.kind {
2815            WakeKind::External => DesktopUserEvent::ExternalWake(WakeSignal),
2816            WakeKind::Reactive => DesktopUserEvent::ReactiveWake(WakeSignal),
2817        };
2818        if self.proxy.send_event(event).is_err() {
2819            self.pending.store(false, Ordering::Release);
2820        }
2821    }
2822}
2823
2824impl ApplicationHandler<DesktopUserEvent> for DesktopApp {
2825    fn resumed(&mut self, event_loop: &ActiveEventLoop) {
2826        crate::motion_preference::sync_system_motion_preference();
2827        if self.host_lifecycle.resume()
2828            && let Err(error) = self.restore_window_surfaces(event_loop)
2829        {
2830            self.handle_error(event_loop, error);
2831            return;
2832        }
2833        if let Err(error) = self.drive_runtime(event_loop) {
2834            self.handle_error(event_loop, error);
2835        }
2836    }
2837
2838    #[cfg(target_arch = "wasm32")]
2839    fn exiting(&mut self, _event_loop: &ActiveEventLoop) {
2840        if let Some(on_exit) = self.on_exit.take() {
2841            on_exit(self.last_error.take().map_or(Ok(()), Err));
2842        }
2843    }
2844
2845    fn memory_warning(&mut self, _event_loop: &ActiveEventLoop) {
2846        // Everything the renderer frees here is rebuilt by the next frame.
2847        self.renderer.trim_memory(MemoryTrimLevel::Critical);
2848    }
2849
2850    fn suspended(&mut self, event_loop: &ActiveEventLoop) {
2851        if let Err(error) = self.suspend_window_surfaces() {
2852            self.handle_error(event_loop, error);
2853            return;
2854        }
2855        event_loop.set_control_flow(ControlFlow::Wait);
2856    }
2857
2858    fn user_event(&mut self, event_loop: &ActiveEventLoop, event: DesktopUserEvent) {
2859        match event {
2860            DesktopUserEvent::ExternalWake(_signal) => {
2861                self.external_wake_pending.store(false, Ordering::Release);
2862                // Scheduler wakes and typed commands are processed outside the
2863                // widget event tree. No synthetic root event is created.
2864                self.runtime.process_commands();
2865                if let Err(error) = self.drive_runtime(event_loop) {
2866                    self.handle_error(event_loop, error);
2867                }
2868            }
2869            DesktopUserEvent::ReactiveWake(_signal) => {
2870                self.reactive_wake_pending.store(false, Ordering::Release);
2871                self.runtime.process_reactive_updates();
2872                if let Err(error) = self.drive_runtime(event_loop) {
2873                    self.handle_error(event_loop, error);
2874                }
2875            }
2876            #[cfg(target_os = "windows")]
2877            DesktopUserEvent::AccessKit(event) => {
2878                if let Err(error) = self.handle_accesskit_event(event_loop, event) {
2879                    self.handle_error(event_loop, error);
2880                }
2881            }
2882        }
2883    }
2884
2885    fn window_event(
2886        &mut self,
2887        event_loop: &ActiveEventLoop,
2888        window_id: HostWindowId,
2889        event: WinitWindowEvent,
2890    ) {
2891        #[cfg(target_os = "windows")]
2892        if matches!(event, WinitWindowEvent::Destroyed) && self.closing_windows.remove(&window_id) {
2893            self.exit_if_windows_closed(event_loop);
2894            return;
2895        }
2896        if !self.host_lifecycle.is_resumed() {
2897            return;
2898        }
2899        if let Err(error) = self.handle_window_event(event_loop, window_id, event) {
2900            self.handle_error(event_loop, error);
2901        }
2902    }
2903
2904    fn device_event(
2905        &mut self,
2906        event_loop: &ActiveEventLoop,
2907        _device_id: DeviceId,
2908        event: DeviceEvent,
2909    ) {
2910        if !self.host_lifecycle.is_resumed() {
2911            return;
2912        }
2913        if let Err(error) = self.handle_device_event(event_loop, event) {
2914            self.handle_error(event_loop, error);
2915        }
2916    }
2917
2918    fn about_to_wait(&mut self, event_loop: &ActiveEventLoop) {
2919        if let Err(error) = self.drive_runtime(event_loop) {
2920            self.handle_error(event_loop, error);
2921        }
2922    }
2923}
2924
2925/// The refresh period of the monitor showing `window`, in seconds, when the
2926/// platform reports it.
2927fn monitor_refresh_interval(window: &Window) -> Option<f64> {
2928    window
2929        .current_monitor()
2930        .and_then(|monitor| monitor.refresh_rate_millihertz())
2931        .filter(|millihertz| *millihertz > 0)
2932        .map(|millihertz| 1000.0 / f64::from(millihertz))
2933}
2934
2935#[cfg_attr(target_arch = "wasm32", allow(dead_code))]
2936struct WindowState {
2937    id: WindowId,
2938    title: String,
2939    display_capabilities_dirty: bool,
2940    awaiting_performance_bootstrap: bool,
2941    redraw_requested: bool,
2942    redraw_requested_at_ms: Option<f64>,
2943    frame_index: u64,
2944    pending_event_time_ms: f64,
2945    last_non_redraw_event_at_ms: Option<f64>,
2946    accessibility: AccessibilityBridge,
2947    #[cfg(target_os = "windows")]
2948    accesskit_adapter: AccessKitAdapter,
2949    #[cfg(target_os = "windows")]
2950    accesskit_snapshot: AccessKitSnapshot,
2951    pointer: PointerState,
2952    focused: bool,
2953    occluded: bool,
2954    applied_cursor_grab: CursorGrabMode,
2955    applied_cursor_revision: u64,
2956    touch_points: HashMap<u64, Point>,
2957    android_back_down_seen: bool,
2958    /// The surface size when the window was suspended, to tell on resume
2959    /// whether layout must change or the retained frame can simply be shown.
2960    suspended_size: Option<PhysicalSize<u32>>,
2961    /// A new surface has no contents, so the next frame must be presented
2962    /// even when nothing in the window changed.
2963    present_pending: bool,
2964    ime_allowed: bool,
2965    scale_factor: f64,
2966    /// The monitor's refresh period, when the platform reports it.
2967    refresh_interval: Option<f64>,
2968    cadence: FrameCadence,
2969    frame_pacing: FramePacing,
2970    window: Arc<Window>,
2971}
2972
2973impl WindowState {
2974    fn snapshot(&self) -> PlatformWindow {
2975        PlatformWindow {
2976            id: self.id,
2977            title: self.title.clone(),
2978            accessibility: self.accessibility.snapshot().cloned(),
2979        }
2980    }
2981}
2982
2983#[derive(Debug, Clone, Copy)]
2984struct PointerState {
2985    position: Point,
2986    buttons: PointerButtons,
2987    modifiers: Modifiers,
2988}
2989
2990impl Default for PointerState {
2991    fn default() -> Self {
2992        Self {
2993            position: Point::ZERO,
2994            buttons: PointerButtons::NONE,
2995            modifiers: Modifiers::NONE,
2996        }
2997    }
2998}
2999
3000fn apply_host_cursor_grab(window: &Window, requested: CursorGrabMode) -> CursorGrabMode {
3001    apply_cursor_grab_with(requested, |mode| window.set_cursor_grab(mode))
3002}
3003
3004fn apply_cursor_grab_with<E>(
3005    requested: CursorGrabMode,
3006    mut set_mode: impl FnMut(WinitCursorGrabMode) -> std::result::Result<(), E>,
3007) -> CursorGrabMode {
3008    match requested {
3009        CursorGrabMode::None => {
3010            let _ = set_mode(WinitCursorGrabMode::None);
3011            CursorGrabMode::None
3012        }
3013        CursorGrabMode::Confined => {
3014            if set_mode(WinitCursorGrabMode::Confined).is_ok() {
3015                CursorGrabMode::Confined
3016            } else {
3017                let _ = set_mode(WinitCursorGrabMode::None);
3018                CursorGrabMode::None
3019            }
3020        }
3021        CursorGrabMode::Locked => {
3022            if set_mode(WinitCursorGrabMode::Locked).is_ok() {
3023                CursorGrabMode::Locked
3024            } else if set_mode(WinitCursorGrabMode::Confined).is_ok() {
3025                CursorGrabMode::Confined
3026            } else {
3027                let _ = set_mode(WinitCursorGrabMode::None);
3028                CursorGrabMode::None
3029            }
3030        }
3031    }
3032}
3033
3034fn release_host_cursor(window: &mut WindowState) {
3035    let _ = window.window.set_cursor_grab(WinitCursorGrabMode::None);
3036    window.window.set_cursor_visible(true);
3037    window.applied_cursor_grab = CursorGrabMode::None;
3038}
3039
3040#[cfg(not(target_arch = "wasm32"))]
3041#[allow(
3042    clippy::cast_possible_truncation,
3043    clippy::cast_precision_loss,
3044    clippy::cast_sign_loss
3045)]
3046fn safe_initial_window_placement(
3047    requested_size: Size,
3048    requested_position: Option<Point>,
3049    monitors: &[MonitorHandle],
3050) -> (Size, Option<Point>) {
3051    let mut size = if requested_size.width.is_finite()
3052        && requested_size.height.is_finite()
3053        && requested_size.width > 0.0
3054        && requested_size.height > 0.0
3055    {
3056        requested_size
3057    } else {
3058        DesktopPlatform::DEFAULT_WINDOW_SIZE
3059    };
3060    size.width = size.width.clamp(320.0, 8_192.0);
3061    size.height = size.height.clamp(240.0, 8_192.0);
3062
3063    let requested_position = requested_position.filter(|position| {
3064        position.x.is_finite()
3065            && position.y.is_finite()
3066            && position.x.abs() <= 1_000_000.0
3067            && position.y.abs() <= 1_000_000.0
3068    });
3069    let mut best = None;
3070    for monitor in monitors {
3071        let origin = monitor.position();
3072        let extent = monitor.size();
3073        let scale = monitor.scale_factor().max(1.0);
3074        let physical_width = f64::from(size.width) * scale;
3075        let physical_height = f64::from(size.height) * scale;
3076        let intersection = requested_position.map_or(0.0, |position| {
3077            let left = f64::from(position.x).max(f64::from(origin.x));
3078            let top = f64::from(position.y).max(f64::from(origin.y));
3079            let right = (f64::from(position.x) + physical_width)
3080                .min(f64::from(origin.x) + f64::from(extent.width));
3081            let bottom = (f64::from(position.y) + physical_height)
3082                .min(f64::from(origin.y) + f64::from(extent.height));
3083            (right - left).max(0.0) * (bottom - top).max(0.0)
3084        });
3085        if best
3086            .as_ref()
3087            .is_none_or(|(_, best_intersection): &(&MonitorHandle, f64)| {
3088                intersection > *best_intersection
3089            })
3090        {
3091            best = Some((monitor, intersection));
3092        }
3093    }
3094
3095    let Some((monitor, intersection)) = best else {
3096        return (size, None);
3097    };
3098    let scale = monitor.scale_factor().max(1.0);
3099    let monitor_size = monitor.size();
3100    size.width = size
3101        .width
3102        .min((f64::from(monitor_size.width) / scale).max(320.0) as f32);
3103    size.height = size
3104        .height
3105        .min((f64::from(monitor_size.height) / scale).max(240.0) as f32);
3106
3107    let Some(position) = requested_position else {
3108        return (size, None);
3109    };
3110    let visible_threshold = 96.0 * 48.0;
3111    if intersection < visible_threshold {
3112        return (size, None);
3113    }
3114    let origin = monitor.position();
3115    let physical_width = f64::from(size.width) * scale;
3116    let minimum_x = f64::from(origin.x) - physical_width + 96.0;
3117    let maximum_x = f64::from(origin.x) + f64::from(monitor_size.width) - 96.0;
3118    let minimum_y = f64::from(origin.y);
3119    let maximum_y = f64::from(origin.y) + f64::from(monitor_size.height) - 48.0;
3120    let x = f64::from(position.x).clamp(minimum_x, maximum_x);
3121    let y = f64::from(position.y).clamp(minimum_y, maximum_y);
3122    (size, Some(Point::new(x as f32, y as f32)))
3123}
3124
3125fn physical_size_to_logical_size(size: PhysicalSize<u32>, scale_factor: f64) -> Size {
3126    let logical = size.to_logical::<f32>(scale_factor);
3127    Size::new(logical.width, logical.height)
3128}
3129
3130fn physical_position_to_logical_point(position: PhysicalPosition<f64>, scale_factor: f64) -> Point {
3131    let logical = position.to_logical::<f32>(scale_factor);
3132    Point::new(logical.x, logical.y)
3133}
3134
3135fn physical_position_to_logical_vector(
3136    position: PhysicalPosition<f64>,
3137    scale_factor: f64,
3138) -> Vector {
3139    let logical = position.to_logical::<f32>(scale_factor);
3140    Vector::new(logical.x, logical.y)
3141}
3142
3143fn raw_mouse_motion_to_vector(delta: (f64, f64)) -> Vector {
3144    Vector::new(delta.0 as f32, delta.1 as f32)
3145}
3146
3147fn apply_ime_composition_rect(
3148    window: &Window,
3149    ime_allowed: &mut bool,
3150    rect: Option<sui_core::Rect>,
3151) {
3152    let cursor_area = rect.and_then(|rect| sanitize_ime_cursor_area(rect, window.scale_factor()));
3153    let next_ime_allowed = cursor_area.is_some();
3154    if next_ime_allowed != *ime_allowed {
3155        window.set_ime_allowed(next_ime_allowed);
3156        *ime_allowed = next_ime_allowed;
3157    }
3158
3159    if let Some((position, size)) = cursor_area {
3160        window.set_ime_cursor_area(position, size);
3161    }
3162}
3163
3164fn sanitize_ime_cursor_area(
3165    rect: sui_core::Rect,
3166    scale_factor: f64,
3167) -> Option<(PhysicalPosition<i32>, PhysicalSize<u32>)> {
3168    if !rect.x().is_finite()
3169        || !rect.y().is_finite()
3170        || !rect.width().is_finite()
3171        || !rect.height().is_finite()
3172    {
3173        return None;
3174    }
3175
3176    let scale_factor = if scale_factor.is_finite() && scale_factor > 0.0 {
3177        scale_factor
3178    } else {
3179        1.0
3180    };
3181    let position = LogicalPosition::new(rect.x() as f64, rect.y() as f64);
3182    let size = LogicalSize::new(rect.width().max(1.0) as f64, rect.height().max(1.0) as f64);
3183    let PhysicalPosition { x, y } = position.to_physical::<i32>(scale_factor);
3184    let PhysicalSize { width, height } = size.to_physical::<i32>(scale_factor);
3185    let x = x.min(i32::MAX - 1);
3186    let y = y.min(i32::MAX - 1);
3187    let max_width = ((i32::MAX as i64) - (x as i64)).clamp(1, i32::MAX as i64) as i32;
3188    let max_height = ((i32::MAX as i64) - (y as i64)).clamp(1, i32::MAX as i64) as i32;
3189    let width = width.clamp(1, max_width) as u32;
3190    let height = height.clamp(1, max_height) as u32;
3191
3192    Some((
3193        PhysicalPosition::new(x, y),
3194        PhysicalSize::new(width, height),
3195    ))
3196}
3197
3198fn modifiers_state_to_modifiers(state: ModifiersState) -> Modifiers {
3199    Modifiers {
3200        shift: state.shift_key(),
3201        control: state.control_key(),
3202        alt: state.alt_key(),
3203        meta: state.super_key(),
3204    }
3205}
3206
3207fn map_mouse_button(button: MouseButton) -> Option<PointerButton> {
3208    match button {
3209        MouseButton::Left => Some(PointerButton::Primary),
3210        MouseButton::Right => Some(PointerButton::Secondary),
3211        MouseButton::Middle => Some(PointerButton::Middle),
3212        MouseButton::Back => Some(PointerButton::Back),
3213        MouseButton::Forward => Some(PointerButton::Forward),
3214        MouseButton::Other(value) => Some(PointerButton::Other(value)),
3215    }
3216}
3217
3218fn remove_pointer_button(buttons: PointerButtons, removed: PointerButton) -> PointerButtons {
3219    let mut next = PointerButtons::NONE;
3220
3221    for button in [
3222        PointerButton::Primary,
3223        PointerButton::Secondary,
3224        PointerButton::Middle,
3225        PointerButton::Back,
3226        PointerButton::Forward,
3227    ] {
3228        if button != removed && buttons.contains(button) {
3229            next.insert(button);
3230        }
3231    }
3232
3233    next
3234}
3235
3236#[cfg(any(target_arch = "wasm32", test))]
3237fn web_click_semantics_action(
3238    node: &sui_core::SemanticsNode,
3239) -> Option<sui_core::SemanticsActionRequest> {
3240    use sui_core::{SemanticsAction, SemanticsActionRequest};
3241
3242    if node.actions.contains(&SemanticsAction::Activate) {
3243        Some(SemanticsActionRequest::Activate)
3244    } else if node.state.expanded == Some(false) && node.actions.contains(&SemanticsAction::Expand)
3245    {
3246        Some(SemanticsActionRequest::Expand)
3247    } else if node.state.expanded == Some(true) && node.actions.contains(&SemanticsAction::Collapse)
3248    {
3249        Some(SemanticsActionRequest::Collapse)
3250    } else if node.actions.contains(&SemanticsAction::Copy) {
3251        Some(SemanticsActionRequest::Copy)
3252    } else {
3253        None
3254    }
3255}
3256
3257#[cfg(target_arch = "wasm32")]
3258fn center(bounds: sui_core::Rect) -> Point {
3259    Point::new(
3260        bounds.x() + (bounds.width() * 0.5),
3261        bounds.y() + (bounds.height() * 0.5),
3262    )
3263}
3264
3265fn logical_key_to_string(key: &Key) -> String {
3266    match key {
3267        Key::Character(text) => text.to_string(),
3268        Key::Named(named) => named_key_to_string(*named),
3269        _ => format!("{key:?}"),
3270    }
3271}
3272
3273fn normalize_android_back_event(
3274    key: &Key,
3275    state: ElementState,
3276    repeat: bool,
3277    down_seen: &mut bool,
3278) -> (ElementState, bool) {
3279    if !matches!(key, Key::Named(NamedKey::BrowserBack)) {
3280        return (state, false);
3281    }
3282
3283    match state {
3284        ElementState::Pressed => {
3285            if !repeat {
3286                *down_seen = true;
3287            }
3288            (state, !repeat)
3289        }
3290        ElementState::Released if std::mem::take(down_seen) => (state, false),
3291        // Android's input queue lets the active IME pre-dispatch Back. Some IMEs consume
3292        // the Down edge and return only Up to the app, so normalize that release-only
3293        // sequence into the single activation expected by the runtime and window host.
3294        ElementState::Released => (ElementState::Pressed, !repeat),
3295    }
3296}
3297
3298fn named_key_to_string(key: NamedKey) -> String {
3299    match key {
3300        NamedKey::Enter => "Enter".to_string(),
3301        NamedKey::Space => " ".to_string(),
3302        NamedKey::Tab => "Tab".to_string(),
3303        NamedKey::Escape => "Escape".to_string(),
3304        NamedKey::ArrowDown => "ArrowDown".to_string(),
3305        NamedKey::ArrowLeft => "ArrowLeft".to_string(),
3306        NamedKey::ArrowRight => "ArrowRight".to_string(),
3307        NamedKey::ArrowUp => "ArrowUp".to_string(),
3308        _ => format!("{key:?}"),
3309    }
3310}
3311
3312fn physical_key_to_string(key: &PhysicalKey) -> String {
3313    match key {
3314        PhysicalKey::Code(code) => format!("{code:?}"),
3315        PhysicalKey::Unidentified(native_key) => format!("{native_key:?}"),
3316    }
3317}
3318
3319fn map_ime_event(event: Ime) -> Option<ImeEvent> {
3320    match event {
3321        Ime::Enabled => Some(ImeEvent::CompositionStart),
3322        Ime::Preedit(text, cursor_range) => Some(ImeEvent::CompositionUpdate {
3323            text,
3324            cursor_range: cursor_range.map(|(start, end)| start..end),
3325        }),
3326        Ime::Commit(text) => Some(ImeEvent::CompositionCommit { text }),
3327        Ime::Disabled => Some(ImeEvent::CompositionEnd),
3328    }
3329}
3330
3331fn map_external_file_window_event(event: &WinitWindowEvent) -> Option<WindowEvent> {
3332    match event {
3333        WinitWindowEvent::HoveredFile(path) => Some(WindowEvent::ExternalFileHovered(path.clone())),
3334        WinitWindowEvent::HoveredFileCancelled => Some(WindowEvent::ExternalFileHoverCancelled),
3335        WinitWindowEvent::DroppedFile(path) => Some(WindowEvent::ExternalFileDropped(path.clone())),
3336        _ => None,
3337    }
3338}
3339
3340#[cfg(not(target_arch = "wasm32"))]
3341fn window_icon_to_winit_icon(icon: &RuntimeWindowIcon) -> Result<WinitIcon> {
3342    match icon {
3343        RuntimeWindowIcon::Svg { data } => svg_window_icon_to_winit_icon(data),
3344        RuntimeWindowIcon::Rgba8 {
3345            width,
3346            height,
3347            data,
3348        } => WinitIcon::from_rgba(data.to_vec(), *width, *height).map_err(map_icon_error),
3349    }
3350}
3351
3352#[cfg(not(target_arch = "wasm32"))]
3353fn svg_window_icon_to_winit_icon(svg: &[u8]) -> Result<WinitIcon> {
3354    let (width, height, rgba) = rasterize_svg_window_icon_rgba8(svg, DEFAULT_WINDOW_ICON_SIZE)?;
3355    WinitIcon::from_rgba(rgba, width, height).map_err(map_icon_error)
3356}
3357
3358#[cfg(not(target_arch = "wasm32"))]
3359fn rasterize_svg_window_icon_rgba8(svg: &[u8], size: u32) -> Result<(u32, u32, Vec<u8>)> {
3360    if size == 0 {
3361        return Err(Error::new("window icon bitmap size must be non-zero"));
3362    }
3363    let options = resvg::usvg::Options::default();
3364    let tree = resvg::usvg::Tree::from_data(svg, &options)
3365        .map_err(|error| Error::new(format!("failed to parse window icon SVG: {error}")))?;
3366    let source_size = tree.size();
3367    let scale = (size as f32 / source_size.width()).min(size as f32 / source_size.height());
3368    let offset_x = (size as f32 - source_size.width() * scale) * 0.5;
3369    let offset_y = (size as f32 - source_size.height() * scale) * 0.5;
3370    let transform =
3371        resvg::tiny_skia::Transform::from_translate(offset_x, offset_y).pre_scale(scale, scale);
3372
3373    let mut pixmap = resvg::tiny_skia::Pixmap::new(size, size)
3374        .ok_or_else(|| Error::new("failed to allocate window icon bitmap"))?;
3375    resvg::render(&tree, transform, &mut pixmap.as_mut());
3376
3377    let mut rgba = Vec::with_capacity((size * size * 4) as usize);
3378    for pixel in pixmap.pixels() {
3379        let color = pixel.demultiply();
3380        rgba.extend_from_slice(&[color.red(), color.green(), color.blue(), color.alpha()]);
3381    }
3382
3383    Ok((size, size, rgba))
3384}
3385
3386#[cfg(not(target_arch = "wasm32"))]
3387fn map_icon_error(error: winit::window::BadIcon) -> Error {
3388    Error::new(format!("failed to create window icon: {error}"))
3389}
3390
3391#[cfg(target_arch = "wasm32")]
3392fn install_web_favicon(icon: Option<&RuntimeWindowIcon>) -> Result<()> {
3393    let Some(document) = web_sys::window().and_then(|window| window.document()) else {
3394        return Ok(());
3395    };
3396    let Some(head) = document.head() else {
3397        return Ok(());
3398    };
3399
3400    remove_web_icon_link(&document, WEB_LEGACY_FAVICON_ID);
3401    let Some(RuntimeWindowIcon::Svg { data }) = icon else {
3402        remove_web_icon_links(&document);
3403        return Ok(());
3404    };
3405
3406    let svg_url = svg_favicon_data_url(data);
3407    install_web_icon_link(
3408        &document,
3409        &head,
3410        WEB_SVG_FAVICON_ID,
3411        "icon",
3412        "image/svg+xml",
3413        "any",
3414        &svg_url,
3415    )?;
3416    install_web_png_icon(
3417        &document,
3418        &head,
3419        data,
3420        WEB_PNG_FAVICON_ID,
3421        "icon",
3422        "64x64",
3423        64,
3424    );
3425    install_web_png_icon(
3426        &document,
3427        &head,
3428        data,
3429        WEB_APPLE_TOUCH_ICON_ID,
3430        "apple-touch-icon",
3431        "180x180",
3432        180,
3433    );
3434    Ok(())
3435}
3436
3437#[cfg(target_arch = "wasm32")]
3438fn install_web_icon_link(
3439    document: &web_sys::Document,
3440    head: &web_sys::HtmlHeadElement,
3441    id: &str,
3442    rel: &str,
3443    mime_type: &str,
3444    sizes: &str,
3445    href: &str,
3446) -> Result<()> {
3447    let link = if let Some(link) = document.get_element_by_id(id) {
3448        link
3449    } else {
3450        let link = document
3451            .create_element("link")
3452            .map_err(|_| Error::new("failed to create web icon link element"))?;
3453        link.set_attribute("id", id)
3454            .map_err(|_| Error::new("failed to configure web icon id"))?;
3455        head.append_child(&link)
3456            .map_err(|_| Error::new("failed to attach web icon link"))?;
3457        link
3458    };
3459
3460    link.set_attribute("rel", rel)
3461        .map_err(|_| Error::new("failed to configure web icon rel"))?;
3462    link.set_attribute("type", mime_type)
3463        .map_err(|_| Error::new("failed to configure web icon type"))?;
3464    if sizes.is_empty() {
3465        link.remove_attribute("sizes")
3466            .map_err(|_| Error::new("failed to clear web icon sizes"))?;
3467    } else {
3468        link.set_attribute("sizes", sizes)
3469            .map_err(|_| Error::new("failed to configure web icon sizes"))?;
3470    }
3471    link.set_attribute("href", href)
3472        .map_err(|_| Error::new("failed to configure web icon href"))
3473}
3474
3475#[cfg(target_arch = "wasm32")]
3476fn remove_web_icon_links(document: &web_sys::Document) {
3477    remove_web_icon_link(document, WEB_SVG_FAVICON_ID);
3478    remove_web_icon_link(document, WEB_PNG_FAVICON_ID);
3479    remove_web_icon_link(document, WEB_APPLE_TOUCH_ICON_ID);
3480}
3481
3482#[cfg(target_arch = "wasm32")]
3483fn remove_web_icon_link(document: &web_sys::Document, id: &str) {
3484    let Some(link) = document.get_element_by_id(id) else {
3485        return;
3486    };
3487    let Some(parent) = link.parent_node() else {
3488        return;
3489    };
3490    let _ = parent.remove_child(&link);
3491}
3492
3493#[cfg(target_arch = "wasm32")]
3494fn svg_favicon_data_url(svg: &[u8]) -> String {
3495    const HEX: &[u8; 16] = b"0123456789ABCDEF";
3496
3497    let mut url = String::from("data:image/svg+xml;charset=utf-8,");
3498    for byte in svg {
3499        match *byte {
3500            b'A'..=b'Z' | b'a'..=b'z' | b'0'..=b'9' | b'-' | b'_' | b'.' | b'~' => {
3501                url.push(*byte as char)
3502            }
3503            byte => {
3504                url.push('%');
3505                url.push(HEX[(byte >> 4) as usize] as char);
3506                url.push(HEX[(byte & 0x0f) as usize] as char);
3507            }
3508        }
3509    }
3510    url
3511}
3512
3513#[cfg(target_arch = "wasm32")]
3514fn install_web_png_icon(
3515    document: &web_sys::Document,
3516    head: &web_sys::HtmlHeadElement,
3517    svg: &[u8],
3518    link_id: &str,
3519    rel: &str,
3520    sizes: &str,
3521    size: u32,
3522) {
3523    use wasm_bindgen::closure::Closure;
3524
3525    let Ok(canvas_element) = document.create_element("canvas") else {
3526        return;
3527    };
3528    let Ok(canvas) = canvas_element.dyn_into::<web_sys::HtmlCanvasElement>() else {
3529        return;
3530    };
3531    canvas.set_width(size);
3532    canvas.set_height(size);
3533
3534    let Ok(Some(context)) = canvas.get_context("2d") else {
3535        return;
3536    };
3537    let Ok(context) = context.dyn_into::<web_sys::CanvasRenderingContext2d>() else {
3538        return;
3539    };
3540    let Ok(image) = web_sys::HtmlImageElement::new() else {
3541        return;
3542    };
3543
3544    let svg_url = svg_favicon_data_url(svg);
3545    let document = document.clone();
3546    let head = head.clone();
3547    let link_id = link_id.to_string();
3548    let rel = rel.to_string();
3549    let sizes = sizes.to_string();
3550    let image_for_load = image.clone();
3551    let onload = Closure::<dyn FnMut()>::new(move || {
3552        let size = size as f64;
3553        context.clear_rect(0.0, 0.0, size, size);
3554        if context
3555            .draw_image_with_html_image_element_and_dw_and_dh(&image_for_load, 0.0, 0.0, size, size)
3556            .is_ok()
3557            && let Ok(png_url) = canvas.to_data_url_with_type("image/png")
3558        {
3559            let _ = install_web_icon_link(
3560                &document,
3561                &head,
3562                &link_id,
3563                &rel,
3564                "image/png",
3565                &sizes,
3566                &png_url,
3567            );
3568        }
3569    });
3570
3571    image.set_onload(Some(onload.as_ref().unchecked_ref()));
3572    image.set_src(&svg_url);
3573    onload.forget();
3574}
3575
3576fn map_event_loop_error(error: EventLoopError) -> Error {
3577    Error::new(format!("winit event loop error: {error}"))
3578}
3579
3580fn map_os_error(error: OsError) -> Error {
3581    Error::new(format!("failed to create desktop window: {error}"))
3582}
3583
3584#[cfg(test)]
3585mod tests {
3586    use std::path::PathBuf;
3587
3588    use super::{
3589        HostLifecycle, apply_cursor_grab_with, map_external_file_window_event,
3590        normalize_android_back_event, physical_position_to_logical_point,
3591        physical_position_to_logical_vector, physical_size_to_logical_size,
3592        rasterize_svg_window_icon_rgba8, raw_mouse_motion_to_vector, sanitize_ime_cursor_area,
3593        web_click_semantics_action, window_icon_to_winit_icon,
3594    };
3595    use sui_core::{
3596        CursorGrabMode, Rect, SemanticsAction, SemanticsActionRequest, SemanticsNode,
3597        SemanticsRole, WindowEvent,
3598    };
3599    use sui_runtime::WindowIcon;
3600    use winit::dpi::{PhysicalPosition, PhysicalSize};
3601    use winit::{
3602        event::{ElementState, WindowEvent as WinitWindowEvent},
3603        keyboard::{Key, NamedKey},
3604        window::CursorGrabMode as WinitCursorGrabMode,
3605    };
3606
3607    #[test]
3608    fn host_lifecycle_waits_for_resume_and_handles_redundant_callbacks() {
3609        let mut lifecycle = HostLifecycle::default();
3610
3611        assert!(!lifecycle.is_resumed());
3612        assert!(!lifecycle.suspend());
3613        assert!(lifecycle.resume());
3614        assert!(lifecycle.is_resumed());
3615        assert!(!lifecycle.resume());
3616        assert!(lifecycle.suspend());
3617        assert!(!lifecycle.is_resumed());
3618        assert!(!lifecycle.suspend());
3619        assert!(lifecycle.resume());
3620    }
3621
3622    #[test]
3623    fn locked_cursor_grab_falls_back_to_confined_then_releases() {
3624        let mut attempts = Vec::new();
3625        let applied = apply_cursor_grab_with(CursorGrabMode::Locked, |mode| {
3626            attempts.push(mode);
3627            match mode {
3628                WinitCursorGrabMode::Locked => Err(()),
3629                WinitCursorGrabMode::Confined => Ok(()),
3630                WinitCursorGrabMode::None => Ok(()),
3631            }
3632        });
3633        assert_eq!(applied, CursorGrabMode::Confined);
3634        assert_eq!(
3635            attempts,
3636            [WinitCursorGrabMode::Locked, WinitCursorGrabMode::Confined]
3637        );
3638
3639        attempts.clear();
3640        let applied = apply_cursor_grab_with(CursorGrabMode::Locked, |mode| {
3641            attempts.push(mode);
3642            (mode == WinitCursorGrabMode::None).then_some(()).ok_or(())
3643        });
3644        assert_eq!(applied, CursorGrabMode::None);
3645        assert_eq!(
3646            attempts,
3647            [
3648                WinitCursorGrabMode::Locked,
3649                WinitCursorGrabMode::Confined,
3650                WinitCursorGrabMode::None
3651            ]
3652        );
3653    }
3654
3655    #[test]
3656    fn converts_physical_size_to_logical_size() {
3657        let size = physical_size_to_logical_size(PhysicalSize::new(640, 360), 2.0);
3658
3659        assert_eq!(size.width, 320.0);
3660        assert_eq!(size.height, 180.0);
3661    }
3662
3663    #[test]
3664    fn converts_physical_pointer_position_to_logical_point() {
3665        let point = physical_position_to_logical_point(PhysicalPosition::new(240.0, 120.0), 1.5);
3666
3667        assert_eq!(point.x, 160.0);
3668        assert_eq!(point.y, 80.0);
3669    }
3670
3671    #[test]
3672    fn converts_physical_scroll_delta_to_logical_vector() {
3673        let delta = physical_position_to_logical_vector(PhysicalPosition::new(90.0, 45.0), 1.5);
3674
3675        assert_eq!(delta.x, 60.0);
3676        assert_eq!(delta.y, 30.0);
3677    }
3678
3679    #[test]
3680    fn preserves_raw_mouse_motion_without_dpi_scaling() {
3681        let delta = raw_mouse_motion_to_vector((12.5, -7.25));
3682
3683        assert_eq!(delta.x, 12.5);
3684        assert_eq!(delta.y, -7.25);
3685    }
3686
3687    #[test]
3688    fn android_back_normalization_activates_once_for_press_and_release() {
3689        let browser_back = Key::Named(NamedKey::BrowserBack);
3690        let mut down_seen = false;
3691
3692        assert_eq!(
3693            normalize_android_back_event(
3694                &browser_back,
3695                ElementState::Pressed,
3696                false,
3697                &mut down_seen,
3698            ),
3699            (ElementState::Pressed, true)
3700        );
3701        assert!(down_seen);
3702        assert_eq!(
3703            normalize_android_back_event(
3704                &browser_back,
3705                ElementState::Released,
3706                false,
3707                &mut down_seen,
3708            ),
3709            (ElementState::Released, false)
3710        );
3711        assert!(!down_seen);
3712        assert_eq!(
3713            normalize_android_back_event(
3714                &browser_back,
3715                ElementState::Pressed,
3716                true,
3717                &mut down_seen,
3718            ),
3719            (ElementState::Pressed, false)
3720        );
3721        assert_eq!(
3722            normalize_android_back_event(
3723                &Key::Named(NamedKey::Escape),
3724                ElementState::Pressed,
3725                false,
3726                &mut down_seen,
3727            ),
3728            (ElementState::Pressed, false)
3729        );
3730    }
3731
3732    #[test]
3733    fn android_back_normalization_promotes_release_only_delivery() {
3734        let mut down_seen = false;
3735        assert_eq!(
3736            normalize_android_back_event(
3737                &Key::Named(NamedKey::BrowserBack),
3738                ElementState::Released,
3739                false,
3740                &mut down_seen,
3741            ),
3742            (ElementState::Pressed, true)
3743        );
3744        assert!(!down_seen);
3745    }
3746
3747    #[test]
3748    fn web_click_prefers_advertised_non_geometric_semantics_actions() {
3749        let mut node = SemanticsNode::new(
3750            sui_core::WidgetId::new(7),
3751            SemanticsRole::Status,
3752            Rect::new(0.0, 0.0, 120.0, 32.0),
3753        );
3754        node.state.expanded = Some(false);
3755        node.actions.push(SemanticsAction::Expand);
3756        assert_eq!(
3757            web_click_semantics_action(&node),
3758            Some(SemanticsActionRequest::Expand)
3759        );
3760
3761        node.state.expanded = Some(true);
3762        node.actions = vec![SemanticsAction::Collapse];
3763        assert_eq!(
3764            web_click_semantics_action(&node),
3765            Some(SemanticsActionRequest::Collapse)
3766        );
3767
3768        node.state.expanded = None;
3769        node.actions = vec![SemanticsAction::Copy];
3770        assert_eq!(
3771            web_click_semantics_action(&node),
3772            Some(SemanticsActionRequest::Copy)
3773        );
3774    }
3775
3776    #[test]
3777    fn maps_winit_external_file_window_events() {
3778        let path = PathBuf::from(r"C:\workspace\agent.json");
3779
3780        assert_eq!(
3781            map_external_file_window_event(&WinitWindowEvent::HoveredFile(path.clone())),
3782            Some(WindowEvent::ExternalFileHovered(path.clone()))
3783        );
3784        assert_eq!(
3785            map_external_file_window_event(&WinitWindowEvent::DroppedFile(path.clone())),
3786            Some(WindowEvent::ExternalFileDropped(path))
3787        );
3788        assert_eq!(
3789            map_external_file_window_event(&WinitWindowEvent::HoveredFileCancelled),
3790            Some(WindowEvent::ExternalFileHoverCancelled)
3791        );
3792        assert_eq!(
3793            map_external_file_window_event(&WinitWindowEvent::Focused(true)),
3794            None
3795        );
3796    }
3797
3798    #[test]
3799    fn sanitize_ime_cursor_area_preserves_valid_geometry() {
3800        let (position, size) =
3801            sanitize_ime_cursor_area(Rect::new(10.0, 20.0, 4.0, 6.0), 1.5).unwrap();
3802
3803        assert_eq!(position, PhysicalPosition::new(15, 30));
3804        assert_eq!(size, PhysicalSize::new(6, 9));
3805    }
3806
3807    #[test]
3808    fn sanitize_ime_cursor_area_clamps_overflowing_geometry() {
3809        let (position, size) =
3810            sanitize_ime_cursor_area(Rect::new(f32::MAX, f32::MAX, f32::MAX, f32::MAX), 1.0)
3811                .unwrap();
3812
3813        assert_eq!(position, PhysicalPosition::new(i32::MAX - 1, i32::MAX - 1));
3814        assert_eq!(size, PhysicalSize::new(1, 1));
3815    }
3816
3817    #[test]
3818    fn sanitize_ime_cursor_area_rejects_non_finite_geometry() {
3819        assert!(sanitize_ime_cursor_area(Rect::new(f32::NAN, 0.0, 10.0, 10.0), 1.0).is_none());
3820        assert!(sanitize_ime_cursor_area(Rect::new(0.0, 0.0, f32::INFINITY, 10.0), 1.0).is_none());
3821    }
3822
3823    #[test]
3824    fn default_svg_window_icon_rasterizes_to_winit_icon() {
3825        assert!(window_icon_to_winit_icon(&WindowIcon::sui()).is_ok());
3826    }
3827
3828    #[test]
3829    fn default_svg_window_icon_rasterizes_to_bitmap() {
3830        let (width, height, rgba) =
3831            rasterize_svg_window_icon_rgba8(WindowIcon::sui().as_svg().unwrap(), 64).unwrap();
3832
3833        assert_eq!((width, height), (64, 64));
3834        assert_eq!(rgba.len(), 64 * 64 * 4);
3835        assert!(rgba.as_chunks::<4>().0.iter().any(|pixel| pixel[3] != 0));
3836    }
3837}