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