Skip to main content

sui_platform/
desktop.rs

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