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        if self.runtime.exit_requested() {
1024            event_loop.exit();
1025            return Ok(());
1026        }
1027
1028        // Winit may deliver AboutToWait and user events before the first
1029        // Resumed callback. In particular, Android has no native window (and
1030        // therefore cannot create a wgpu surface) during that interval.
1031        if !self.host_lifecycle.is_resumed() {
1032            event_loop.set_control_flow(ControlFlow::Wait);
1033            return Ok(());
1034        }
1035
1036        self.sync_windows(event_loop)?;
1037        if self.windows.is_empty() {
1038            return Ok(());
1039        }
1040
1041        self.update_clock();
1042        self.runtime.tick(self.frame_clock);
1043
1044        while self.dispatch_ready_events(event_loop)? {}
1045
1046        self.sync_windows(event_loop)?;
1047
1048        self.sync_extensions()?;
1049
1050        #[cfg(target_arch = "wasm32")]
1051        self.process_web_interop_commands(event_loop)?;
1052
1053        let window_ids: Vec<_> = self.windows.keys().copied().collect();
1054        for window_id in window_ids.iter().copied() {
1055            self.sync_frame_pacing(window_id)?;
1056            self.request_redraw_if_needed(window_id)?;
1057        }
1058
1059        self.drive_automation(event_loop)?;
1060        if self
1061            .automation
1062            .as_ref()
1063            .is_some_and(|automation| automation.shutdown_requested)
1064        {
1065            let window_ids = self.runtime.window_ids();
1066            for window_id in window_ids {
1067                self.runtime.remove_window(window_id)?;
1068                crate::clear_window_performance(window_id);
1069            }
1070            self.sync_windows(event_loop)?;
1071            return Ok(());
1072        }
1073
1074        self.update_control_flow(event_loop)?;
1075        Ok(())
1076    }
1077
1078    fn dispatch_ready_events(&mut self, event_loop: &ActiveEventLoop) -> Result<bool> {
1079        let events = self.runtime.drain_ready_events();
1080        let had_events = !events.is_empty();
1081        for (window_id, event) in events {
1082            if self.windows.contains_key(&window_id) {
1083                self.process_event(event_loop, window_id, event)?;
1084            }
1085        }
1086        Ok(had_events)
1087    }
1088
1089    /// Pace animation frames by the display while the window presents with
1090    /// vsync, and by the runtime's timer when it is hidden or unsynchronized
1091    /// (a hidden window gets no redraws to pace by).
1092    fn sync_frame_pacing(&mut self, window_id: WindowId) -> Result<()> {
1093        let vsync = self.renderer.vsync_enabled();
1094        let Some(window) = self.windows.get_mut(&window_id) else {
1095            return Ok(());
1096        };
1097        let size = window.window.inner_size();
1098        let presenting = !window.occluded
1099            && window.window.is_minimized() != Some(true)
1100            && size.width > 0
1101            && size.height > 0;
1102        let pacing = if vsync && presenting {
1103            FramePacing::Display
1104        } else {
1105            FramePacing::Timer
1106        };
1107        if window.frame_pacing != pacing {
1108            window.frame_pacing = pacing;
1109            window.cadence = FrameCadence::default();
1110            self.runtime.set_frame_pacing(window_id, pacing)?;
1111        }
1112        Ok(())
1113    }
1114
1115    /// Start a display-paced animation frame before rendering, stamped with
1116    /// the time the frame should reach the screen.
1117    fn begin_display_paced_frame(
1118        &mut self,
1119        event_loop: &ActiveEventLoop,
1120        window_id: WindowId,
1121    ) -> Result<()> {
1122        let now = self.frame_clock;
1123        let Some(window) = self.windows.get_mut(&window_id) else {
1124            return Ok(());
1125        };
1126        if window.frame_pacing != FramePacing::Display
1127            || !self.runtime.has_pending_animation_frames(window_id)?
1128        {
1129            return Ok(());
1130        }
1131        let frame_time = window.cadence.next(now, window.refresh_interval);
1132        for event in self.runtime.begin_animation_frame(window_id, frame_time)? {
1133            self.process_event(event_loop, window_id, event)?;
1134        }
1135        Ok(())
1136    }
1137
1138    fn request_redraw_if_needed(&mut self, window_id: WindowId) -> Result<()> {
1139        // A focused VSync window must keep presenting even when its retained UI
1140        // is unchanged. Otherwise windowed VRR can lower the whole monitor's
1141        // refresh rate while the user is interacting with an idle view.
1142        let keep_presenting = self.renderer.vsync_enabled()
1143            && self
1144                .windows
1145                .get(&window_id)
1146                .is_some_and(|window| window.focused);
1147        // Display-paced animation needs a redraw to start its next frame,
1148        // even before anything has been invalidated.
1149        let animating = self
1150            .windows
1151            .get(&window_id)
1152            .is_some_and(|window| window.frame_pacing == FramePacing::Display)
1153            && self.runtime.has_pending_animation_frames(window_id)?;
1154        let capturing = crate::has_pending_window_debug_captures(window_id);
1155        if !self.runtime.needs_render(window_id)? && !keep_presenting && !animating && !capturing {
1156            return Ok(());
1157        }
1158
1159        let now_ms = self.current_time_ms();
1160
1161        let Some(window) = self.windows.get_mut(&window_id) else {
1162            return Ok(());
1163        };
1164
1165        let size = window.window.inner_size();
1166        if window.occluded
1167            || window.window.is_minimized() == Some(true)
1168            || size.width == 0
1169            || size.height == 0
1170        {
1171            return Ok(());
1172        }
1173        if window.redraw_requested {
1174            return Ok(());
1175        }
1176
1177        window.redraw_requested = true;
1178        window.redraw_requested_at_ms = Some(now_ms);
1179        window.window.request_redraw();
1180        Ok(())
1181    }
1182
1183    fn update_clock(&mut self) {
1184        self.frame_clock = self.started_at.elapsed().as_secs_f64();
1185    }
1186
1187    fn current_time_ms(&self) -> f64 {
1188        self.started_at.elapsed().as_secs_f64() * 1000.0
1189    }
1190
1191    fn update_control_flow(&self, event_loop: &ActiveEventLoop) -> Result<()> {
1192        if self.windows.is_empty() {
1193            event_loop.exit();
1194            return Ok(());
1195        }
1196
1197        let mut next_deadline: Option<f64> = None;
1198
1199        for window_id in self.runtime.window_ids() {
1200            let deadline = self.runtime.next_wakeup_time(window_id)?;
1201            next_deadline = match (next_deadline, deadline) {
1202                (Some(current), Some(candidate)) => Some(current.min(candidate)),
1203                (None, Some(candidate)) => Some(candidate),
1204                (current, None) => current,
1205            };
1206        }
1207
1208        if let Some(automation_deadline) = self
1209            .automation
1210            .as_ref()
1211            .and_then(DesktopAutomationState::next_deadline)
1212        {
1213            let candidate = (automation_deadline - self.started_at).as_secs_f64();
1214            next_deadline = match next_deadline {
1215                Some(current) => Some(current.min(candidate)),
1216                None => Some(candidate),
1217            };
1218        }
1219
1220        if let Some(interval) = self
1221            .extensions
1222            .iter()
1223            .filter_map(|extension| extension.poll_interval())
1224            .min()
1225        {
1226            let candidate = self.frame_clock + interval.as_secs_f64();
1227            next_deadline = match next_deadline {
1228                Some(current) => Some(current.min(candidate)),
1229                None => Some(candidate),
1230            };
1231        }
1232
1233        match next_deadline {
1234            Some(deadline) if deadline <= self.frame_clock => {
1235                event_loop.set_control_flow(ControlFlow::Poll);
1236            }
1237            Some(deadline) => {
1238                let when = self.started_at + Duration::from_secs_f64(deadline.max(0.0));
1239                event_loop.set_control_flow(ControlFlow::WaitUntil(when));
1240            }
1241            None => event_loop.set_control_flow(ControlFlow::Wait),
1242        }
1243
1244        Ok(())
1245    }
1246
1247    fn process_event(
1248        &mut self,
1249        event_loop: &ActiveEventLoop,
1250        window_id: WindowId,
1251        event: Event,
1252    ) -> Result<()> {
1253        self.process_event_with_outcome(event_loop, window_id, event)
1254            .map(|_| ())
1255    }
1256
1257    fn process_event_with_outcome(
1258        &mut self,
1259        event_loop: &ActiveEventLoop,
1260        window_id: WindowId,
1261        event: Event,
1262    ) -> Result<bool> {
1263        if !self.windows.contains_key(&window_id) {
1264            return Ok(false);
1265        }
1266
1267        let event_arrived_at_ms = self.current_time_ms();
1268
1269        let is_redraw = matches!(event, Event::Window(WindowEvent::RedrawRequested));
1270        let is_close = matches!(event, Event::Window(WindowEvent::CloseRequested));
1271
1272        // Event handlers start widget motion from EventCtx::current_time(). Keep that
1273        // time current for input after the event loop has been idle, not only for
1274        // redraw and ready-event delivery.
1275        self.update_clock();
1276        self.runtime.tick(self.frame_clock);
1277
1278        if is_redraw {
1279            // Windows can deliver WM_PAINT inside its modal move/resize loop
1280            // without AboutToWait. Advance one batch of due wakes so animation
1281            // and timers do not freeze while the title bar or border is held.
1282            // Do not chase newly scheduled future deadlines in this callback.
1283            self.dispatch_ready_events(event_loop)?;
1284            self.begin_display_paced_frame(event_loop, window_id)?;
1285        }
1286
1287        let event_started = Instant::now();
1288        let handled = self.runtime.dispatch_event(window_id, event)?;
1289        let event_time_ms = event_started.elapsed().as_secs_f64() * 1000.0;
1290
1291        self.sync_window_cursor(window_id)?;
1292
1293        // Idle pointer motion can run for seconds without requesting a frame.
1294        // Charge input work only while a frame is pending, otherwise the next
1295        // redraw inherits an arbitrarily large, unrelated "frame time".
1296        if !is_redraw
1297            && !is_close
1298            && self.runtime.needs_render(window_id)?
1299            && let Some(window) = self.windows.get_mut(&window_id)
1300        {
1301            window.pending_event_time_ms += event_time_ms;
1302            window.last_non_redraw_event_at_ms = Some(event_arrived_at_ms);
1303        }
1304
1305        if !is_redraw && !is_close {
1306            self.request_redraw_if_needed(window_id)?;
1307        }
1308
1309        // Render only in response to `RedrawRequested`. Every other event (resize, scale
1310        // change, input) marks the schedule and asks winit for a redraw via
1311        // `request_redraw_if_needed` above; winit then delivers `RedrawRequested` and we render
1312        // here. Rendering synchronously inside the originating event instead clears the frame
1313        // schedule, so the redraw winit subsequently delivers finds `needs_render() == false`
1314        // and becomes a no-op — and a synchronous present issued inside a `Resized` callback is
1315        // not reliably composited (notably during the Windows modal resize loop), leaving the
1316        // window stale until an unrelated event repaints it.
1317        if is_redraw {
1318            if let Some(window) = self.windows.get_mut(&window_id) {
1319                window.redraw_requested = false;
1320            }
1321
1322            self.render_window_if_needed(window_id, event_time_ms)?;
1323            self.service_debug_captures(window_id)?;
1324            // Chain continuous presentation from WM_PAINT/RedrawRequested;
1325            // AboutToWait alone cannot sustain it during an OS modal loop.
1326            self.request_redraw_if_needed(window_id)?;
1327        }
1328
1329        if is_close {
1330            if let Some(window) = self.windows.get_mut(&window_id) {
1331                release_host_cursor(window);
1332            }
1333            self.runtime.remove_window(window_id)?;
1334            crate::clear_window_performance(window_id);
1335            self.sync_windows(event_loop)?;
1336            self.sync_extensions()?;
1337        }
1338
1339        if self.windows.is_empty() {
1340            event_loop.exit();
1341        }
1342
1343        Ok(handled)
1344    }
1345
1346    fn sync_window_cursor(&mut self, window_id: WindowId) -> Result<()> {
1347        let desired = self.runtime.window_cursor_state(window_id)?;
1348        let Some(window) = self.windows.get_mut(&window_id) else {
1349            return Ok(());
1350        };
1351        if window.applied_cursor_revision == desired.revision {
1352            return Ok(());
1353        }
1354
1355        let requested_grab = if window.focused {
1356            desired.grab_mode
1357        } else {
1358            CursorGrabMode::None
1359        };
1360        window.applied_cursor_grab = apply_host_cursor_grab(window.window.as_ref(), requested_grab);
1361        window
1362            .window
1363            .set_cursor_visible(desired.visible || !window.focused);
1364        window.applied_cursor_revision = desired.revision;
1365        Ok(())
1366    }
1367
1368    /// Make the captures the app asked for from the frame just presented,
1369    /// then wake the widgets waiting for them.
1370    fn service_debug_captures(&mut self, window_id: WindowId) -> Result<()> {
1371        for token in crate::service_window_debug_captures(&mut self.renderer, window_id) {
1372            self.runtime.wake_async(window_id, token)?;
1373        }
1374        Ok(())
1375    }
1376
1377    fn render_window_if_needed(&mut self, window_id: WindowId, event_time_ms: f64) -> Result<()> {
1378        // Windows can still deliver redraws and async wakes while minimized.
1379        // Preserve pending runtime work until there is a drawable native surface.
1380        if self.windows.get(&window_id).is_none_or(|host| {
1381            let size = host.window.inner_size();
1382            host.occluded
1383                || host.window.is_minimized() == Some(true)
1384                || size.width == 0
1385                || size.height == 0
1386        }) {
1387            return Ok(());
1388        }
1389        if !self.runtime.needs_render(window_id)? {
1390            return Ok(());
1391        }
1392
1393        self.update_clock();
1394        self.runtime.tick(self.frame_clock);
1395
1396        let render_started_at_ms = self.current_time_ms();
1397        let mut presentation_latency = PresentationLatencyDiagnostics::default();
1398        if let Some(window) = self.windows.get(&window_id) {
1399            presentation_latency = PresentationLatencyDiagnostics::new(
1400                window
1401                    .last_non_redraw_event_at_ms
1402                    .map(|timestamp| (render_started_at_ms - timestamp).max(0.0))
1403                    .unwrap_or(0.0),
1404                0.0,
1405                window
1406                    .redraw_requested_at_ms
1407                    .map(|timestamp| (render_started_at_ms - timestamp).max(0.0))
1408                    .unwrap_or(0.0),
1409            );
1410        }
1411
1412        if self
1413            .windows
1414            .get(&window_id)
1415            .is_some_and(|window| window.display_capabilities_dirty)
1416        {
1417            self.refresh_window_display_capabilities(window_id)?;
1418            if let Some(window) = self.windows.get_mut(&window_id) {
1419                window.display_capabilities_dirty = false;
1420            }
1421        }
1422        let PresentedFrame {
1423            output,
1424            runtime_time_ms,
1425            renderer_time_ms,
1426            presented_at,
1427        } = present_window_frame(&mut self.runtime, &mut self.renderer, window_id)?;
1428        // A render pass can rebuild the widget graph after reactive state
1429        // removed the cursor owner. Apply the runtime's resulting reset even
1430        // when no further input event arrives.
1431        self.sync_window_cursor(window_id)?;
1432        let semantics = output.semantics.clone();
1433        let presented_at = (!self.extensions.is_empty()).then_some(presented_at);
1434        let presented_at_ms = self.current_time_ms();
1435        if let Some(window) = self.windows.get(&window_id) {
1436            presentation_latency.event_to_present_ms = window
1437                .last_non_redraw_event_at_ms
1438                .map(|timestamp| (presented_at_ms - timestamp).max(0.0))
1439                .unwrap_or(0.0);
1440        }
1441
1442        let mut frame_index = 0;
1443        let mut pending_event_time_ms = 0.0;
1444
1445        if let Some(window) = self.windows.get_mut(&window_id) {
1446            frame_index = window.frame_index + 1;
1447            pending_event_time_ms = std::mem::take(&mut window.pending_event_time_ms);
1448            window.frame_index = frame_index;
1449
1450            if window.title != output.title {
1451                window.title = output.title.clone();
1452                window.window.set_title(&output.title);
1453            }
1454
1455            #[cfg(target_os = "windows")]
1456            {
1457                let scale_factor = window.scale_factor;
1458                let WindowState {
1459                    accesskit_adapter,
1460                    accesskit_snapshot,
1461                    ..
1462                } = window;
1463                accesskit_adapter.update_if_active(|| {
1464                    let snapshot = build_accesskit_snapshot(
1465                        window_id,
1466                        scale_factor,
1467                        &output.title,
1468                        &semantics,
1469                    );
1470                    let update = snapshot.full_update();
1471                    *accesskit_snapshot = snapshot;
1472                    update
1473                });
1474            }
1475
1476            window.accessibility.update(window_id, semantics);
1477            window.last_non_redraw_event_at_ms = None;
1478            window.redraw_requested_at_ms = None;
1479
1480            apply_ime_composition_rect(
1481                window.window.as_ref(),
1482                &mut window.ime_allowed,
1483                output.ime_composition_rect,
1484            );
1485        }
1486
1487        crate::publish_frame_performance(
1488            window_id,
1489            frame_index,
1490            pending_event_time_ms,
1491            event_time_ms,
1492            runtime_time_ms,
1493            presentation_latency,
1494            &output,
1495            &self.renderer,
1496            renderer_time_ms,
1497        );
1498
1499        if let Some(presented_at) = presented_at {
1500            let commands = self.runtime.command_sender();
1501            for extension in &mut self.extensions {
1502                extension.frame_presented(
1503                    DesktopExtensionContext {
1504                        runtime: &self.runtime,
1505                        renderer: &self.renderer,
1506                        windows: &self.windows,
1507                        commands: &commands,
1508                    },
1509                    DesktopFramePresented {
1510                        window_id,
1511                        frame_index,
1512                        presented_at,
1513                        runtime_duration: Duration::from_secs_f64(runtime_time_ms / 1000.0),
1514                    },
1515                )?;
1516            }
1517        }
1518
1519        #[cfg(target_arch = "wasm32")]
1520        if let Some(window) = self.windows.get(&window_id) {
1521            let performance = window_performance_snapshot(window_id);
1522            crate::web_interop::publish_snapshot(
1523                window_id,
1524                frame_index,
1525                window.scale_factor,
1526                output.frame.viewport,
1527                &output.semantics,
1528                performance.as_ref(),
1529            );
1530        }
1531
1532        let bootstrap_redraw_at_ms = self.current_time_ms();
1533        if let Some(window) = self.windows.get_mut(&window_id)
1534            && window.awaiting_performance_bootstrap
1535        {
1536            window.awaiting_performance_bootstrap = false;
1537            if !window.redraw_requested {
1538                window.redraw_requested = true;
1539                window.redraw_requested_at_ms = Some(bootstrap_redraw_at_ms);
1540                window.window.request_redraw();
1541            }
1542        }
1543
1544        Ok(())
1545    }
1546
1547    fn handle_window_event(
1548        &mut self,
1549        event_loop: &ActiveEventLoop,
1550        host_id: HostWindowId,
1551        event: WinitWindowEvent,
1552    ) -> Result<()> {
1553        let Some(window_id) = self.host_to_runtime.get(&host_id).copied() else {
1554            return Ok(());
1555        };
1556
1557        #[cfg(target_os = "windows")]
1558        if let Some(window) = self.windows.get_mut(&window_id) {
1559            // AccessKit's winit adapter must see each native window event first so
1560            // focus, geometry, and lifecycle state stay synchronized with UIA.
1561            window
1562                .accesskit_adapter
1563                .process_event(window.window.as_ref(), &event);
1564        }
1565
1566        if let Some(file_event) = map_external_file_window_event(&event) {
1567            return self.process_event(event_loop, window_id, Event::Window(file_event));
1568        }
1569
1570        match event {
1571            WinitWindowEvent::CloseRequested => self.process_event(
1572                event_loop,
1573                window_id,
1574                Event::Window(WindowEvent::CloseRequested),
1575            ),
1576            // A minimized Windows surface reports zero dimensions. Keep the
1577            // last valid layout and process the restoring nonzero resize.
1578            WinitWindowEvent::Resized(size) if size.width == 0 || size.height == 0 => Ok(()),
1579            WinitWindowEvent::Resized(size) => self.process_event(
1580                event_loop,
1581                window_id,
1582                Event::Window(WindowEvent::Resized(
1583                    self.windows
1584                        .get(&window_id)
1585                        .map(|window| physical_size_to_logical_size(size, window.scale_factor))
1586                        .unwrap_or_else(|| physical_size_to_logical_size(size, 1.0)),
1587                )),
1588            ),
1589            WinitWindowEvent::Moved(position) => {
1590                // The window may now be on a monitor with another refresh rate.
1591                if let Some(window) = self.windows.get_mut(&window_id) {
1592                    window.refresh_interval = monitor_refresh_interval(&window.window);
1593                }
1594                self.process_event(
1595                    event_loop,
1596                    window_id,
1597                    Event::Window(WindowEvent::Moved(Point::new(
1598                        position.x as f32,
1599                        position.y as f32,
1600                    ))),
1601                )
1602            }
1603            WinitWindowEvent::ScaleFactorChanged { scale_factor, .. } => {
1604                let suggested_size = self.windows.get_mut(&window_id).map(|window| {
1605                    window.scale_factor = scale_factor;
1606                    window.display_capabilities_dirty = true;
1607                    window.refresh_interval = monitor_refresh_interval(&window.window);
1608                    physical_size_to_logical_size(window.window.inner_size(), scale_factor)
1609                });
1610                self.process_event(
1611                    event_loop,
1612                    window_id,
1613                    Event::Window(WindowEvent::ScaleFactorChanged {
1614                        scale_factor,
1615                        raw_dpi: None,
1616                        suggested_size,
1617                    }),
1618                )
1619            }
1620            WinitWindowEvent::Focused(focused) => {
1621                if focused {
1622                    // The setting may have changed while another app had focus.
1623                    crate::motion_preference::sync_system_motion_preference();
1624                }
1625                if let Some(window) = self.windows.get_mut(&window_id) {
1626                    window.focused = focused;
1627                    if !focused {
1628                        window.android_back_down_seen = false;
1629                        release_host_cursor(window);
1630                    }
1631                }
1632                self.process_event(
1633                    event_loop,
1634                    window_id,
1635                    Event::Window(WindowEvent::Focused(focused)),
1636                )
1637            }
1638            WinitWindowEvent::Occluded(occluded) => {
1639                if let Some(window) = self.windows.get_mut(&window_id) {
1640                    window.occluded = occluded;
1641                }
1642                self.process_event(
1643                    event_loop,
1644                    window_id,
1645                    Event::Window(WindowEvent::Occluded(occluded)),
1646                )
1647            }
1648            WinitWindowEvent::RedrawRequested => self.process_event(
1649                event_loop,
1650                window_id,
1651                Event::Window(WindowEvent::RedrawRequested),
1652            ),
1653            WinitWindowEvent::ModifiersChanged(modifiers) => {
1654                if let Some(window) = self.windows.get_mut(&window_id) {
1655                    window.pointer.modifiers = modifiers_state_to_modifiers(modifiers.state());
1656                }
1657                Ok(())
1658            }
1659            WinitWindowEvent::CursorMoved { position, .. } => {
1660                let event = if let Some(window) = self.windows.get_mut(&window_id) {
1661                    let next_position =
1662                        physical_position_to_logical_point(position, window.scale_factor);
1663                    let delta = Vector::new(
1664                        next_position.x - window.pointer.position.x,
1665                        next_position.y - window.pointer.position.y,
1666                    );
1667                    window.pointer.position = next_position;
1668                    Event::Pointer(PointerEvent {
1669                        pointer_id: 1,
1670                        kind: PointerEventKind::Move,
1671                        position: next_position,
1672                        delta,
1673                        scroll_delta: None,
1674                        button: None,
1675                        buttons: window.pointer.buttons,
1676                        modifiers: window.pointer.modifiers,
1677                        pointer_kind: PointerKind::Mouse,
1678                        is_primary: true,
1679                    })
1680                } else {
1681                    return Ok(());
1682                };
1683
1684                self.process_event(event_loop, window_id, event)
1685            }
1686            WinitWindowEvent::CursorEntered { .. } => {
1687                let event = if let Some(window) = self.windows.get(&window_id) {
1688                    Event::Pointer(PointerEvent {
1689                        pointer_id: 1,
1690                        kind: PointerEventKind::Enter,
1691                        position: window.pointer.position,
1692                        delta: Vector::ZERO,
1693                        scroll_delta: None,
1694                        button: None,
1695                        buttons: window.pointer.buttons,
1696                        modifiers: window.pointer.modifiers,
1697                        pointer_kind: PointerKind::Mouse,
1698                        is_primary: true,
1699                    })
1700                } else {
1701                    return Ok(());
1702                };
1703
1704                self.process_event(event_loop, window_id, event)
1705            }
1706            WinitWindowEvent::CursorLeft { .. } => {
1707                let event = if let Some(window) = self.windows.get(&window_id) {
1708                    Event::Pointer(PointerEvent {
1709                        pointer_id: 1,
1710                        kind: PointerEventKind::Leave,
1711                        position: window.pointer.position,
1712                        delta: Vector::ZERO,
1713                        scroll_delta: None,
1714                        button: None,
1715                        buttons: window.pointer.buttons,
1716                        modifiers: window.pointer.modifiers,
1717                        pointer_kind: PointerKind::Mouse,
1718                        is_primary: true,
1719                    })
1720                } else {
1721                    return Ok(());
1722                };
1723
1724                self.process_event(event_loop, window_id, event)
1725            }
1726            WinitWindowEvent::MouseInput { state, button, .. } => {
1727                let event = if let Some(window) = self.windows.get_mut(&window_id) {
1728                    let Some(pointer_button) = map_mouse_button(button) else {
1729                        return Ok(());
1730                    };
1731
1732                    match state {
1733                        ElementState::Pressed => window.pointer.buttons.insert(pointer_button),
1734                        ElementState::Released => {
1735                            window.pointer.buttons =
1736                                remove_pointer_button(window.pointer.buttons, pointer_button);
1737                        }
1738                    }
1739
1740                    Event::Pointer(PointerEvent {
1741                        pointer_id: 1,
1742                        kind: match state {
1743                            ElementState::Pressed => PointerEventKind::Down,
1744                            ElementState::Released => PointerEventKind::Up,
1745                        },
1746                        position: window.pointer.position,
1747                        delta: Vector::ZERO,
1748                        scroll_delta: None,
1749                        button: Some(pointer_button),
1750                        buttons: window.pointer.buttons,
1751                        modifiers: window.pointer.modifiers,
1752                        pointer_kind: PointerKind::Mouse,
1753                        is_primary: true,
1754                    })
1755                } else {
1756                    return Ok(());
1757                };
1758
1759                self.process_event(event_loop, window_id, event)
1760            }
1761            WinitWindowEvent::MouseWheel { delta, .. } => {
1762                let event = if let Some(window) = self.windows.get(&window_id) {
1763                    Event::Pointer(PointerEvent {
1764                        pointer_id: 1,
1765                        kind: PointerEventKind::Scroll,
1766                        position: window.pointer.position,
1767                        delta: Vector::ZERO,
1768                        scroll_delta: Some(match delta {
1769                            MouseScrollDelta::LineDelta(x, y) => {
1770                                ScrollDelta::Lines(Vector::new(x, y))
1771                            }
1772                            MouseScrollDelta::PixelDelta(position) => ScrollDelta::Pixels(
1773                                physical_position_to_logical_vector(position, window.scale_factor),
1774                            ),
1775                        }),
1776                        button: None,
1777                        buttons: window.pointer.buttons,
1778                        modifiers: window.pointer.modifiers,
1779                        pointer_kind: PointerKind::Mouse,
1780                        is_primary: true,
1781                    })
1782                } else {
1783                    return Ok(());
1784                };
1785
1786                self.process_event(event_loop, window_id, event)
1787            }
1788            WinitWindowEvent::Touch(touch) => {
1789                let event = if let Some(window) = self.windows.get_mut(&window_id) {
1790                    let position =
1791                        physical_position_to_logical_point(touch.location, window.scale_factor);
1792                    let previous = window
1793                        .touch_points
1794                        .get(&touch.id)
1795                        .copied()
1796                        .unwrap_or(position);
1797                    let kind = match touch.phase {
1798                        TouchPhase::Started => PointerEventKind::Down,
1799                        TouchPhase::Moved => PointerEventKind::Move,
1800                        TouchPhase::Ended => PointerEventKind::Up,
1801                        TouchPhase::Cancelled => PointerEventKind::Cancel,
1802                    };
1803                    let was_primary = window
1804                        .touch_points
1805                        .keys()
1806                        .min()
1807                        .copied()
1808                        .map(|id| id == touch.id)
1809                        .unwrap_or(true);
1810                    match touch.phase {
1811                        TouchPhase::Started | TouchPhase::Moved => {
1812                            window.touch_points.insert(touch.id, position);
1813                        }
1814                        TouchPhase::Ended | TouchPhase::Cancelled => {
1815                            window.touch_points.remove(&touch.id);
1816                        }
1817                    }
1818                    let buttons = match touch.phase {
1819                        TouchPhase::Started | TouchPhase::Moved => PointerButtons::new(1),
1820                        TouchPhase::Ended | TouchPhase::Cancelled => PointerButtons::NONE,
1821                    };
1822                    Event::Pointer(PointerEvent {
1823                        pointer_id: touch.id,
1824                        kind,
1825                        position,
1826                        delta: Vector::new(position.x - previous.x, position.y - previous.y),
1827                        scroll_delta: None,
1828                        button: match touch.phase {
1829                            TouchPhase::Started | TouchPhase::Ended => Some(PointerButton::Primary),
1830                            TouchPhase::Moved | TouchPhase::Cancelled => None,
1831                        },
1832                        buttons,
1833                        modifiers: window.pointer.modifiers,
1834                        pointer_kind: PointerKind::Touch,
1835                        is_primary: was_primary,
1836                    })
1837                } else {
1838                    return Ok(());
1839                };
1840
1841                self.process_event(event_loop, window_id, event)
1842            }
1843            WinitWindowEvent::KeyboardInput { event, .. } => {
1844                let (effective_state, is_android_back) = if cfg!(target_os = "android") {
1845                    let down_seen = self
1846                        .windows
1847                        .get_mut(&window_id)
1848                        .map(|window| &mut window.android_back_down_seen);
1849                    down_seen.map_or((event.state, false), |down_seen| {
1850                        normalize_android_back_event(
1851                            &event.logical_key,
1852                            event.state,
1853                            event.repeat,
1854                            down_seen,
1855                        )
1856                    })
1857                } else {
1858                    (event.state, false)
1859                };
1860                let modifiers = self
1861                    .windows
1862                    .get(&window_id)
1863                    .map(|window| window.pointer.modifiers)
1864                    .unwrap_or(Modifiers::NONE);
1865                let keyboard_event = KeyboardEvent {
1866                    key: logical_key_to_string(&event.logical_key),
1867                    code: physical_key_to_string(&event.physical_key),
1868                    text: event.text.as_ref().map(|text| text.to_string()),
1869                    state: match effective_state {
1870                        ElementState::Pressed => KeyState::Pressed,
1871                        ElementState::Released => KeyState::Released,
1872                    },
1873                    modifiers,
1874                    repeat: event.repeat,
1875                    is_composing: false,
1876                };
1877                let handled = self.process_event_with_outcome(
1878                    event_loop,
1879                    window_id,
1880                    Event::Keyboard(keyboard_event),
1881                )?;
1882                if is_android_back && !handled {
1883                    self.process_event(
1884                        event_loop,
1885                        window_id,
1886                        Event::Window(WindowEvent::CloseRequested),
1887                    )?;
1888                }
1889                Ok(())
1890            }
1891            WinitWindowEvent::Ime(ime) => {
1892                if let Some(ime_event) = map_ime_event(ime) {
1893                    self.process_event(event_loop, window_id, Event::Ime(ime_event))
1894                } else {
1895                    Ok(())
1896                }
1897            }
1898            _ => Ok(()),
1899        }
1900    }
1901
1902    fn handle_device_event(
1903        &mut self,
1904        event_loop: &ActiveEventLoop,
1905        event: DeviceEvent,
1906    ) -> Result<()> {
1907        let DeviceEvent::MouseMotion { delta } = event else {
1908            return Ok(());
1909        };
1910        let Some((window_id, modifiers)) = self.windows.iter().find_map(|(&window_id, window)| {
1911            (window.focused && window.applied_cursor_grab != CursorGrabMode::None)
1912                .then_some((window_id, window.pointer.modifiers))
1913        }) else {
1914            return Ok(());
1915        };
1916        let delta = raw_mouse_motion_to_vector(delta);
1917        self.process_event(
1918            event_loop,
1919            window_id,
1920            Event::RawMouseMotion(RawMouseMotionEvent { delta, modifiers }),
1921        )
1922    }
1923
1924    #[cfg(target_os = "windows")]
1925    fn handle_accesskit_event(
1926        &mut self,
1927        event_loop: &ActiveEventLoop,
1928        event: AccessKitEvent,
1929    ) -> Result<()> {
1930        let Some(window_id) = self.host_to_runtime.get(&event.window_id).copied() else {
1931            return Ok(());
1932        };
1933
1934        match event.window_event {
1935            AccessKitWindowEvent::InitialTreeRequested => {
1936                let Some(window) = self.windows.get_mut(&window_id) else {
1937                    return Ok(());
1938                };
1939                let snapshot = build_accesskit_snapshot(
1940                    window_id,
1941                    window.scale_factor,
1942                    &window.title,
1943                    window
1944                        .accessibility
1945                        .snapshot()
1946                        .map(|snapshot| snapshot.nodes.as_slice())
1947                        .unwrap_or(&[]),
1948                );
1949                let update = snapshot.full_update();
1950                window.accesskit_snapshot = snapshot;
1951                let WindowState {
1952                    accesskit_adapter, ..
1953                } = window;
1954                accesskit_adapter.update_if_active(|| update);
1955                Ok(())
1956            }
1957            AccessKitWindowEvent::ActionRequested(request) => {
1958                let mapped = self
1959                    .windows
1960                    .get(&window_id)
1961                    .and_then(|window| window.accesskit_snapshot.map_action(&request));
1962                let Some((target, action)) = mapped else {
1963                    return Ok(());
1964                };
1965
1966                // Accessibility callbacks arrive through the event-loop proxy, so
1967                // widget state continues to be mutated exclusively on the UI thread.
1968                self.update_clock();
1969                self.runtime.tick(self.frame_clock);
1970                let _handled = self
1971                    .runtime
1972                    .handle_semantics_action(window_id, target, action)?;
1973                self.drive_runtime(event_loop)
1974            }
1975            AccessKitWindowEvent::AccessibilityDeactivated => Ok(()),
1976        }
1977    }
1978
1979    fn handle_error(&mut self, event_loop: &ActiveEventLoop, error: Error) {
1980        self.last_error = Some(error);
1981        event_loop.exit();
1982    }
1983
1984    fn drive_automation(&mut self, event_loop: &ActiveEventLoop) -> Result<()> {
1985        let now = Instant::now();
1986        let mut state = match self.automation.take() {
1987            Some(state) => state,
1988            None => return Ok(()),
1989        };
1990
1991        if state.shutdown_requested {
1992            self.automation = Some(state);
1993            return Ok(());
1994        }
1995
1996        if state.started_at.is_none() && now >= state.armed_at + state.config.startup_timeout {
1997            println!(
1998                "[desktop automation:{}] timed out waiting for target {:?} named {:?}",
1999                state.config.label, state.config.target_role, state.config.target_name
2000            );
2001            state.shutdown_requested = true;
2002            self.automation = Some(state);
2003            return Ok(());
2004        }
2005
2006        if let Some((window_id, target_point)) = self.find_automation_target(&state) {
2007            if state.started_at.is_none() {
2008                state.started_at = Some(now);
2009                state.last_report_at = Some(now);
2010                state.last_report_frame_index = window_performance_snapshot(window_id)
2011                    .map(|snapshot| snapshot.frame_index)
2012                    .unwrap_or(0);
2013                state.target_window_id = Some(window_id);
2014                println!(
2015                    "[desktop automation:{}] started on window {}",
2016                    state.config.label,
2017                    window_id.get()
2018                );
2019                self.process_event(
2020                    event_loop,
2021                    window_id,
2022                    Event::Window(WindowEvent::Focused(true)),
2023                )?;
2024            }
2025
2026            if !state.pointer_primed {
2027                self.inject_pointer_move(event_loop, window_id, target_point, true)?;
2028                state.pointer_primed = true;
2029            }
2030
2031            self.report_automation_progress(&mut state, false);
2032
2033            let started_at = state.started_at.expect("automation should have started");
2034            if now >= started_at + state.config.duration {
2035                self.report_automation_progress(&mut state, true);
2036                println!("[desktop automation:{}] completed", state.config.label);
2037                state.shutdown_requested = true;
2038                self.automation = Some(state);
2039                return Ok(());
2040            }
2041
2042            if now >= state.next_step_at {
2043                self.inject_automation_action(
2044                    event_loop,
2045                    window_id,
2046                    target_point,
2047                    &state.config.action,
2048                )?;
2049                state.next_step_at = now + state.config.step_interval;
2050            }
2051        }
2052
2053        self.automation = Some(state);
2054        Ok(())
2055    }
2056
2057    fn find_automation_target(&self, state: &DesktopAutomationState) -> Option<(WindowId, Point)> {
2058        self.windows.iter().find_map(|(window_id, window)| {
2059            let snapshot = window.accessibility.snapshot()?;
2060            let node = snapshot.nodes.iter().find(|node| {
2061                node.role == state.config.target_role
2062                    && node.name.as_deref() == Some(state.config.target_name.as_str())
2063            })?;
2064            let point = if node.role == SemanticsRole::ScrollView {
2065                Point::new(
2066                    node.bounds.x() + node.bounds.width().min(48.0),
2067                    node.bounds.y() + node.bounds.height() * 0.5,
2068                )
2069            } else {
2070                Point::new(
2071                    node.bounds.x() + node.bounds.width() * 0.5,
2072                    node.bounds.y() + node.bounds.height() * 0.5,
2073                )
2074            };
2075            Some((*window_id, point))
2076        })
2077    }
2078
2079    fn report_automation_progress(&self, state: &mut DesktopAutomationState, force: bool) {
2080        let Some(window_id) = state.target_window_id else {
2081            return;
2082        };
2083        let now = Instant::now();
2084        let Some(last_report_at) = state.last_report_at else {
2085            state.last_report_at = Some(now);
2086            return;
2087        };
2088        if !force && now < last_report_at + state.config.report_interval {
2089            return;
2090        }
2091        let Some(snapshot) = window_performance_snapshot(window_id) else {
2092            state.last_report_at = Some(now);
2093            return;
2094        };
2095        let elapsed = (now - last_report_at).as_secs_f64().max(f64::EPSILON);
2096        let frame_delta = snapshot
2097            .frame_index
2098            .saturating_sub(state.last_report_frame_index);
2099        let observed_fps = frame_delta as f64 / elapsed;
2100        Self::print_automation_snapshot(&state.config.label, observed_fps, &snapshot);
2101        state.last_report_at = Some(now);
2102        state.last_report_frame_index = snapshot.frame_index;
2103    }
2104
2105    fn print_automation_snapshot(
2106        label: &str,
2107        observed_fps: f64,
2108        snapshot: &WindowPerformanceSnapshot,
2109    ) {
2110        let slowest_phase = snapshot
2111            .slowest_phase()
2112            .map(|sample| format!("{}:{:.3}ms", sample.phase.label(), sample.duration_ms))
2113            .unwrap_or_else(|| "n/a".to_string());
2114        let phase_breakdown = if snapshot.phase_timings.is_empty() {
2115            "n/a".to_string()
2116        } else {
2117            snapshot
2118                .phase_timings
2119                .iter()
2120                .map(|sample| format!("{}={:.3}", sample.phase.label(), sample.duration_ms))
2121                .collect::<Vec<_>>()
2122                .join(",")
2123        };
2124        let renderer_breakdown = format!(
2125            "comp={:.3},traverse={:.3},batch={:.3},upload={:.3},encode={:.3},submit={:.3},res={:.3},bind={:.3},atlas_miss={}({:.3}ms)",
2126            snapshot.renderer_submission.composition_time_us as f64 / 1000.0,
2127            snapshot
2128                .renderer_submission
2129                .retained_scene_traversal_time_us as f64
2130                / 1000.0,
2131            snapshot.renderer_submission.batch_prepare_time_us as f64 / 1000.0,
2132            snapshot.renderer_submission.gpu_upload_time_us as f64 / 1000.0,
2133            snapshot.renderer_submission.pass_encode_time_us as f64 / 1000.0,
2134            snapshot.renderer_submission.queue_submit_time_us as f64 / 1000.0,
2135            snapshot.renderer_submission.resource_collection_time_us as f64 / 1000.0,
2136            snapshot.renderer_submission.bind_group_prepare_time_us as f64 / 1000.0,
2137            snapshot.renderer_submission.text_atlas_miss_count,
2138            snapshot.renderer_submission.text_atlas_miss_time_us as f64 / 1000.0,
2139        );
2140        let hotspot = snapshot
2141            .retained_packet_hotspot
2142            .as_ref()
2143            .map(|hotspot| {
2144                format!(
2145                    "widget={:?},total={:.3}ms,cmds={},text={},paths={},rects={}",
2146                    hotspot.owner_widget_id,
2147                    hotspot.total_time_us as f64 / 1000.0,
2148                    hotspot.command_count,
2149                    hotspot.text_command_count,
2150                    hotspot.path_command_count,
2151                    hotspot.rect_command_count,
2152                )
2153            })
2154            .unwrap_or_else(|| "n/a".to_string());
2155        println!(
2156            "[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=[{}]",
2157            snapshot.frame_index,
2158            snapshot.total_time_ms,
2159            slowest_phase,
2160            snapshot.scene.dirty_coverage,
2161            snapshot.scene.command_count,
2162            snapshot.renderer_submission.surface_acquire_time_us as f64 / 1000.0,
2163            snapshot.renderer_submission.surface_present_time_us as f64 / 1000.0,
2164            snapshot.renderer_submission.retained_packet_build_time_us as f64 / 1000.0,
2165            snapshot.renderer_submission.retained_state_update_time_us as f64 / 1000.0,
2166            snapshot.renderer_submission.visible_layer_count,
2167            snapshot.renderer_submission.draw_count,
2168            phase_breakdown,
2169            renderer_breakdown,
2170            hotspot,
2171        );
2172    }
2173
2174    #[cfg(target_arch = "wasm32")]
2175    fn process_web_interop_commands(&mut self, event_loop: &ActiveEventLoop) -> Result<()> {
2176        for command in crate::web_interop::drain_commands() {
2177            match command {
2178                crate::web_interop::WebInteropCommand::Click { target } => {
2179                    if let Some((window_id, node)) = self.find_semantics_node(&target) {
2180                        if let Some(action) = web_click_semantics_action(&node) {
2181                            let _ = self
2182                                .runtime
2183                                .handle_semantics_action(window_id, node.id, action)?;
2184                        } else {
2185                            self.inject_pointer_click(event_loop, window_id, center(node.bounds))?;
2186                        }
2187                    }
2188                }
2189                crate::web_interop::WebInteropCommand::Scroll {
2190                    target,
2191                    delta_x,
2192                    delta_y,
2193                } => {
2194                    if let Some((window_id, point)) = self.find_semantics_node_point(&target) {
2195                        self.inject_pointer_scroll(
2196                            event_loop,
2197                            window_id,
2198                            point,
2199                            Vector::new(delta_x, delta_y),
2200                        )?;
2201                    }
2202                }
2203                crate::web_interop::WebInteropCommand::Key { target, key } => {
2204                    if let Some((window_id, point)) = self.find_semantics_node_point(&target) {
2205                        self.inject_pointer_click(event_loop, window_id, point)?;
2206                        self.inject_key(event_loop, window_id, key)?;
2207                    }
2208                }
2209                crate::web_interop::WebInteropCommand::Text { target, text } => {
2210                    if let Some((window_id, point)) = self.find_semantics_node_point(&target) {
2211                        self.inject_pointer_click(event_loop, window_id, point)?;
2212                        self.inject_text(event_loop, window_id, text)?;
2213                    }
2214                }
2215            }
2216        }
2217
2218        Ok(())
2219    }
2220
2221    #[cfg(target_arch = "wasm32")]
2222    fn find_semantics_node(
2223        &self,
2224        target: &crate::web_interop::WebInteropTarget,
2225    ) -> Option<(WindowId, sui_core::SemanticsNode)> {
2226        self.windows.iter().find_map(|(window_id, window)| {
2227            let snapshot = window.accessibility.snapshot()?;
2228            let node = target
2229                .widget_id
2230                .and_then(|widget_id| snapshot.nodes.iter().find(|node| node.id == widget_id))
2231                .or_else(|| {
2232                    snapshot.nodes.iter().find(|node| {
2233                        target.role.as_deref().is_none_or(|role| {
2234                            format!("{:?}", node.role).eq_ignore_ascii_case(role)
2235                        }) && target
2236                            .name
2237                            .as_deref()
2238                            .is_none_or(|name| node.name.as_deref() == Some(name))
2239                    })
2240                })?;
2241            Some((*window_id, node.clone()))
2242        })
2243    }
2244
2245    #[cfg(target_arch = "wasm32")]
2246    fn find_semantics_node_point(
2247        &self,
2248        target: &crate::web_interop::WebInteropTarget,
2249    ) -> Option<(WindowId, Point)> {
2250        self.find_semantics_node(target)
2251            .map(|(window_id, node)| (window_id, center(node.bounds)))
2252    }
2253
2254    #[cfg(target_arch = "wasm32")]
2255    fn inject_pointer_click(
2256        &mut self,
2257        event_loop: &ActiveEventLoop,
2258        window_id: WindowId,
2259        point: Point,
2260    ) -> Result<()> {
2261        self.inject_pointer_move(event_loop, window_id, point, false)?;
2262        let modifiers = self
2263            .windows
2264            .get(&window_id)
2265            .map(|window| window.pointer.modifiers)
2266            .ok_or_else(|| Error::new(format!("missing window {}", window_id.get())))?;
2267
2268        let down_buttons = {
2269            let window = self
2270                .windows
2271                .get_mut(&window_id)
2272                .ok_or_else(|| Error::new(format!("missing window {}", window_id.get())))?;
2273            window.pointer.buttons.insert(PointerButton::Primary);
2274            window.pointer.buttons
2275        };
2276        self.process_event(
2277            event_loop,
2278            window_id,
2279            Event::Pointer(PointerEvent {
2280                pointer_id: 1,
2281                kind: PointerEventKind::Down,
2282                position: point,
2283                delta: Vector::ZERO,
2284                scroll_delta: None,
2285                button: Some(PointerButton::Primary),
2286                buttons: down_buttons,
2287                modifiers,
2288                pointer_kind: PointerKind::Mouse,
2289                is_primary: true,
2290            }),
2291        )?;
2292
2293        let up_buttons = {
2294            let window = self
2295                .windows
2296                .get_mut(&window_id)
2297                .ok_or_else(|| Error::new(format!("missing window {}", window_id.get())))?;
2298            window.pointer.buttons =
2299                remove_pointer_button(window.pointer.buttons, PointerButton::Primary);
2300            window.pointer.buttons
2301        };
2302        self.process_event(
2303            event_loop,
2304            window_id,
2305            Event::Pointer(PointerEvent {
2306                pointer_id: 1,
2307                kind: PointerEventKind::Up,
2308                position: point,
2309                delta: Vector::ZERO,
2310                scroll_delta: None,
2311                button: Some(PointerButton::Primary),
2312                buttons: up_buttons,
2313                modifiers,
2314                pointer_kind: PointerKind::Mouse,
2315                is_primary: true,
2316            }),
2317        )
2318    }
2319
2320    #[cfg(target_arch = "wasm32")]
2321    fn inject_pointer_scroll(
2322        &mut self,
2323        event_loop: &ActiveEventLoop,
2324        window_id: WindowId,
2325        point: Point,
2326        delta: Vector,
2327    ) -> Result<()> {
2328        self.inject_pointer_move(event_loop, window_id, point, false)?;
2329        let (buttons, modifiers) = self
2330            .windows
2331            .get(&window_id)
2332            .map(|window| (window.pointer.buttons, window.pointer.modifiers))
2333            .ok_or_else(|| Error::new(format!("missing window {}", window_id.get())))?;
2334        self.process_event(
2335            event_loop,
2336            window_id,
2337            Event::Pointer(PointerEvent {
2338                pointer_id: 1,
2339                kind: PointerEventKind::Scroll,
2340                position: point,
2341                delta: Vector::ZERO,
2342                scroll_delta: Some(ScrollDelta::Pixels(delta)),
2343                button: None,
2344                buttons,
2345                modifiers,
2346                pointer_kind: PointerKind::Mouse,
2347                is_primary: true,
2348            }),
2349        )
2350    }
2351
2352    #[cfg(target_arch = "wasm32")]
2353    fn inject_key(
2354        &mut self,
2355        event_loop: &ActiveEventLoop,
2356        window_id: WindowId,
2357        key: String,
2358    ) -> Result<()> {
2359        self.process_event(
2360            event_loop,
2361            window_id,
2362            Event::Keyboard(KeyboardEvent::new(key.clone(), KeyState::Pressed)),
2363        )?;
2364        self.process_event(
2365            event_loop,
2366            window_id,
2367            Event::Keyboard(KeyboardEvent::new(key, KeyState::Released)),
2368        )
2369    }
2370
2371    #[cfg(target_arch = "wasm32")]
2372    fn inject_text(
2373        &mut self,
2374        event_loop: &ActiveEventLoop,
2375        window_id: WindowId,
2376        text: String,
2377    ) -> Result<()> {
2378        self.process_event(
2379            event_loop,
2380            window_id,
2381            Event::Ime(ImeEvent::CompositionStart),
2382        )?;
2383        self.process_event(
2384            event_loop,
2385            window_id,
2386            Event::Ime(ImeEvent::CompositionUpdate {
2387                text: text.clone(),
2388                cursor_range: None,
2389            }),
2390        )?;
2391        self.process_event(
2392            event_loop,
2393            window_id,
2394            Event::Ime(ImeEvent::CompositionCommit { text }),
2395        )?;
2396        self.process_event(event_loop, window_id, Event::Ime(ImeEvent::CompositionEnd))
2397    }
2398
2399    fn inject_automation_action(
2400        &mut self,
2401        event_loop: &ActiveEventLoop,
2402        window_id: WindowId,
2403        target_point: Point,
2404        action: &DesktopAutomationAction,
2405    ) -> Result<()> {
2406        match action {
2407            DesktopAutomationAction::ScrollPixels { delta } => {
2408                self.inject_pointer_move(event_loop, window_id, target_point, false)?;
2409                let (buttons, modifiers) = self
2410                    .windows
2411                    .get(&window_id)
2412                    .map(|window| (window.pointer.buttons, window.pointer.modifiers))
2413                    .ok_or_else(|| Error::new(format!("missing window {}", window_id.get())))?;
2414                self.process_event(
2415                    event_loop,
2416                    window_id,
2417                    Event::Pointer(PointerEvent {
2418                        pointer_id: 1,
2419                        kind: PointerEventKind::Scroll,
2420                        position: target_point,
2421                        delta: Vector::ZERO,
2422                        scroll_delta: Some(ScrollDelta::Pixels(*delta)),
2423                        button: None,
2424                        buttons,
2425                        modifiers,
2426                        pointer_kind: PointerKind::Mouse,
2427                        is_primary: true,
2428                    }),
2429                )
2430            }
2431        }
2432    }
2433
2434    fn inject_pointer_move(
2435        &mut self,
2436        event_loop: &ActiveEventLoop,
2437        window_id: WindowId,
2438        position: Point,
2439        emit_enter: bool,
2440    ) -> Result<()> {
2441        let (previous, buttons, modifiers) = {
2442            let window = self
2443                .windows
2444                .get(&window_id)
2445                .ok_or_else(|| Error::new(format!("missing window {}", window_id.get())))?;
2446            (
2447                window.pointer.position,
2448                window.pointer.buttons,
2449                window.pointer.modifiers,
2450            )
2451        };
2452
2453        if emit_enter {
2454            self.process_event(
2455                event_loop,
2456                window_id,
2457                Event::Pointer(PointerEvent {
2458                    pointer_id: 1,
2459                    kind: PointerEventKind::Enter,
2460                    position,
2461                    delta: Vector::ZERO,
2462                    scroll_delta: None,
2463                    button: None,
2464                    buttons,
2465                    modifiers,
2466                    pointer_kind: PointerKind::Mouse,
2467                    is_primary: true,
2468                }),
2469            )?;
2470        }
2471
2472        if let Some(window) = self.windows.get_mut(&window_id) {
2473            window.pointer.position = position;
2474        }
2475
2476        self.process_event(
2477            event_loop,
2478            window_id,
2479            Event::Pointer(PointerEvent {
2480                pointer_id: 1,
2481                kind: PointerEventKind::Move,
2482                position,
2483                delta: Vector::new(position.x - previous.x, position.y - previous.y),
2484                scroll_delta: None,
2485                button: None,
2486                buttons,
2487                modifiers,
2488                pointer_kind: PointerKind::Mouse,
2489                is_primary: true,
2490            }),
2491        )
2492    }
2493}
2494
2495/// Background-thread signal that wakes the desktop event loop (carried as a winit user event).
2496#[derive(Debug, Clone, Copy)]
2497pub struct WakeSignal;
2498
2499/// A cheap, cloneable, `Send` handle that wakes the running desktop UI from any thread.
2500/// Pending [`wake`](Self::wake) calls are coalesced into one event-loop signal. This is a
2501/// scheduler primitive: it does not synthesize or route a widget event.
2502#[derive(Clone)]
2503pub struct Waker {
2504    proxy: EventLoopProxy<DesktopUserEvent>,
2505    pending: Arc<AtomicBool>,
2506    kind: WakeKind,
2507}
2508
2509#[derive(Debug, Clone, Copy)]
2510enum WakeKind {
2511    External,
2512    Reactive,
2513}
2514
2515impl Waker {
2516    fn new(
2517        proxy: EventLoopProxy<DesktopUserEvent>,
2518        pending: Arc<AtomicBool>,
2519        kind: WakeKind,
2520    ) -> Self {
2521        Self {
2522            proxy,
2523            pending,
2524            kind,
2525        }
2526    }
2527
2528    pub fn wake(&self) {
2529        if self
2530            .pending
2531            .compare_exchange(false, true, Ordering::AcqRel, Ordering::Acquire)
2532            .is_err()
2533        {
2534            return;
2535        }
2536        let event = match self.kind {
2537            WakeKind::External => DesktopUserEvent::ExternalWake(WakeSignal),
2538            WakeKind::Reactive => DesktopUserEvent::ReactiveWake(WakeSignal),
2539        };
2540        if self.proxy.send_event(event).is_err() {
2541            self.pending.store(false, Ordering::Release);
2542        }
2543    }
2544}
2545
2546impl ApplicationHandler<DesktopUserEvent> for DesktopApp {
2547    fn resumed(&mut self, event_loop: &ActiveEventLoop) {
2548        crate::motion_preference::sync_system_motion_preference();
2549        if self.host_lifecycle.resume()
2550            && let Err(error) = self.restore_window_surfaces(event_loop)
2551        {
2552            self.handle_error(event_loop, error);
2553            return;
2554        }
2555        if let Err(error) = self.drive_runtime(event_loop) {
2556            self.handle_error(event_loop, error);
2557        }
2558    }
2559
2560    fn suspended(&mut self, event_loop: &ActiveEventLoop) {
2561        if let Err(error) = self.suspend_window_surfaces() {
2562            self.handle_error(event_loop, error);
2563            return;
2564        }
2565        event_loop.set_control_flow(ControlFlow::Wait);
2566    }
2567
2568    fn user_event(&mut self, event_loop: &ActiveEventLoop, event: DesktopUserEvent) {
2569        match event {
2570            DesktopUserEvent::ExternalWake(_signal) => {
2571                self.external_wake_pending.store(false, Ordering::Release);
2572                // Scheduler wakes and typed commands are processed outside the
2573                // widget event tree. No synthetic root event is created.
2574                self.runtime.process_commands();
2575                if let Err(error) = self.drive_runtime(event_loop) {
2576                    self.handle_error(event_loop, error);
2577                }
2578            }
2579            DesktopUserEvent::ReactiveWake(_signal) => {
2580                self.reactive_wake_pending.store(false, Ordering::Release);
2581                self.runtime.process_reactive_updates();
2582                if let Err(error) = self.drive_runtime(event_loop) {
2583                    self.handle_error(event_loop, error);
2584                }
2585            }
2586            #[cfg(target_os = "windows")]
2587            DesktopUserEvent::AccessKit(event) => {
2588                if let Err(error) = self.handle_accesskit_event(event_loop, event) {
2589                    self.handle_error(event_loop, error);
2590                }
2591            }
2592        }
2593    }
2594
2595    fn window_event(
2596        &mut self,
2597        event_loop: &ActiveEventLoop,
2598        window_id: HostWindowId,
2599        event: WinitWindowEvent,
2600    ) {
2601        if !self.host_lifecycle.is_resumed() {
2602            return;
2603        }
2604        if let Err(error) = self.handle_window_event(event_loop, window_id, event) {
2605            self.handle_error(event_loop, error);
2606        }
2607    }
2608
2609    fn device_event(
2610        &mut self,
2611        event_loop: &ActiveEventLoop,
2612        _device_id: DeviceId,
2613        event: DeviceEvent,
2614    ) {
2615        if !self.host_lifecycle.is_resumed() {
2616            return;
2617        }
2618        if let Err(error) = self.handle_device_event(event_loop, event) {
2619            self.handle_error(event_loop, error);
2620        }
2621    }
2622
2623    fn about_to_wait(&mut self, event_loop: &ActiveEventLoop) {
2624        if let Err(error) = self.drive_runtime(event_loop) {
2625            self.handle_error(event_loop, error);
2626        }
2627    }
2628}
2629
2630/// The refresh period of the monitor showing `window`, in seconds, when the
2631/// platform reports it.
2632fn monitor_refresh_interval(window: &Window) -> Option<f64> {
2633    window
2634        .current_monitor()
2635        .and_then(|monitor| monitor.refresh_rate_millihertz())
2636        .filter(|millihertz| *millihertz > 0)
2637        .map(|millihertz| 1000.0 / f64::from(millihertz))
2638}
2639
2640#[cfg_attr(target_arch = "wasm32", allow(dead_code))]
2641struct WindowState {
2642    id: WindowId,
2643    title: String,
2644    display_capabilities_dirty: bool,
2645    awaiting_performance_bootstrap: bool,
2646    redraw_requested: bool,
2647    redraw_requested_at_ms: Option<f64>,
2648    frame_index: u64,
2649    pending_event_time_ms: f64,
2650    last_non_redraw_event_at_ms: Option<f64>,
2651    accessibility: AccessibilityBridge,
2652    #[cfg(target_os = "windows")]
2653    accesskit_adapter: AccessKitAdapter,
2654    #[cfg(target_os = "windows")]
2655    accesskit_snapshot: AccessKitSnapshot,
2656    pointer: PointerState,
2657    focused: bool,
2658    occluded: bool,
2659    applied_cursor_grab: CursorGrabMode,
2660    applied_cursor_revision: u64,
2661    touch_points: HashMap<u64, Point>,
2662    android_back_down_seen: bool,
2663    ime_allowed: bool,
2664    scale_factor: f64,
2665    /// The monitor's refresh period, when the platform reports it.
2666    refresh_interval: Option<f64>,
2667    cadence: FrameCadence,
2668    frame_pacing: FramePacing,
2669    window: Arc<Window>,
2670}
2671
2672impl WindowState {
2673    fn snapshot(&self) -> PlatformWindow {
2674        PlatformWindow {
2675            id: self.id,
2676            title: self.title.clone(),
2677            accessibility: self.accessibility.snapshot().cloned(),
2678        }
2679    }
2680}
2681
2682#[derive(Debug, Clone, Copy)]
2683struct PointerState {
2684    position: Point,
2685    buttons: PointerButtons,
2686    modifiers: Modifiers,
2687}
2688
2689impl Default for PointerState {
2690    fn default() -> Self {
2691        Self {
2692            position: Point::ZERO,
2693            buttons: PointerButtons::NONE,
2694            modifiers: Modifiers::NONE,
2695        }
2696    }
2697}
2698
2699fn apply_host_cursor_grab(window: &Window, requested: CursorGrabMode) -> CursorGrabMode {
2700    apply_cursor_grab_with(requested, |mode| window.set_cursor_grab(mode))
2701}
2702
2703fn apply_cursor_grab_with<E>(
2704    requested: CursorGrabMode,
2705    mut set_mode: impl FnMut(WinitCursorGrabMode) -> std::result::Result<(), E>,
2706) -> CursorGrabMode {
2707    match requested {
2708        CursorGrabMode::None => {
2709            let _ = set_mode(WinitCursorGrabMode::None);
2710            CursorGrabMode::None
2711        }
2712        CursorGrabMode::Confined => {
2713            if set_mode(WinitCursorGrabMode::Confined).is_ok() {
2714                CursorGrabMode::Confined
2715            } else {
2716                let _ = set_mode(WinitCursorGrabMode::None);
2717                CursorGrabMode::None
2718            }
2719        }
2720        CursorGrabMode::Locked => {
2721            if set_mode(WinitCursorGrabMode::Locked).is_ok() {
2722                CursorGrabMode::Locked
2723            } else if set_mode(WinitCursorGrabMode::Confined).is_ok() {
2724                CursorGrabMode::Confined
2725            } else {
2726                let _ = set_mode(WinitCursorGrabMode::None);
2727                CursorGrabMode::None
2728            }
2729        }
2730    }
2731}
2732
2733fn release_host_cursor(window: &mut WindowState) {
2734    let _ = window.window.set_cursor_grab(WinitCursorGrabMode::None);
2735    window.window.set_cursor_visible(true);
2736    window.applied_cursor_grab = CursorGrabMode::None;
2737}
2738
2739#[cfg(not(target_arch = "wasm32"))]
2740#[allow(
2741    clippy::cast_possible_truncation,
2742    clippy::cast_precision_loss,
2743    clippy::cast_sign_loss
2744)]
2745fn safe_initial_window_placement(
2746    requested_size: Size,
2747    requested_position: Option<Point>,
2748    monitors: &[MonitorHandle],
2749) -> (Size, Option<Point>) {
2750    let mut size = if requested_size.width.is_finite()
2751        && requested_size.height.is_finite()
2752        && requested_size.width > 0.0
2753        && requested_size.height > 0.0
2754    {
2755        requested_size
2756    } else {
2757        DesktopPlatform::DEFAULT_WINDOW_SIZE
2758    };
2759    size.width = size.width.clamp(320.0, 8_192.0);
2760    size.height = size.height.clamp(240.0, 8_192.0);
2761
2762    let requested_position = requested_position.filter(|position| {
2763        position.x.is_finite()
2764            && position.y.is_finite()
2765            && position.x.abs() <= 1_000_000.0
2766            && position.y.abs() <= 1_000_000.0
2767    });
2768    let mut best = None;
2769    for monitor in monitors {
2770        let origin = monitor.position();
2771        let extent = monitor.size();
2772        let scale = monitor.scale_factor().max(1.0);
2773        let physical_width = f64::from(size.width) * scale;
2774        let physical_height = f64::from(size.height) * scale;
2775        let intersection = requested_position.map_or(0.0, |position| {
2776            let left = f64::from(position.x).max(f64::from(origin.x));
2777            let top = f64::from(position.y).max(f64::from(origin.y));
2778            let right = (f64::from(position.x) + physical_width)
2779                .min(f64::from(origin.x) + f64::from(extent.width));
2780            let bottom = (f64::from(position.y) + physical_height)
2781                .min(f64::from(origin.y) + f64::from(extent.height));
2782            (right - left).max(0.0) * (bottom - top).max(0.0)
2783        });
2784        if best
2785            .as_ref()
2786            .is_none_or(|(_, best_intersection): &(&MonitorHandle, f64)| {
2787                intersection > *best_intersection
2788            })
2789        {
2790            best = Some((monitor, intersection));
2791        }
2792    }
2793
2794    let Some((monitor, intersection)) = best else {
2795        return (size, None);
2796    };
2797    let scale = monitor.scale_factor().max(1.0);
2798    let monitor_size = monitor.size();
2799    size.width = size
2800        .width
2801        .min((f64::from(monitor_size.width) / scale).max(320.0) as f32);
2802    size.height = size
2803        .height
2804        .min((f64::from(monitor_size.height) / scale).max(240.0) as f32);
2805
2806    let Some(position) = requested_position else {
2807        return (size, None);
2808    };
2809    let visible_threshold = 96.0 * 48.0;
2810    if intersection < visible_threshold {
2811        return (size, None);
2812    }
2813    let origin = monitor.position();
2814    let physical_width = f64::from(size.width) * scale;
2815    let minimum_x = f64::from(origin.x) - physical_width + 96.0;
2816    let maximum_x = f64::from(origin.x) + f64::from(monitor_size.width) - 96.0;
2817    let minimum_y = f64::from(origin.y);
2818    let maximum_y = f64::from(origin.y) + f64::from(monitor_size.height) - 48.0;
2819    let x = f64::from(position.x).clamp(minimum_x, maximum_x);
2820    let y = f64::from(position.y).clamp(minimum_y, maximum_y);
2821    (size, Some(Point::new(x as f32, y as f32)))
2822}
2823
2824fn physical_size_to_logical_size(size: PhysicalSize<u32>, scale_factor: f64) -> Size {
2825    let logical = size.to_logical::<f32>(scale_factor);
2826    Size::new(logical.width, logical.height)
2827}
2828
2829fn physical_position_to_logical_point(position: PhysicalPosition<f64>, scale_factor: f64) -> Point {
2830    let logical = position.to_logical::<f32>(scale_factor);
2831    Point::new(logical.x, logical.y)
2832}
2833
2834fn physical_position_to_logical_vector(
2835    position: PhysicalPosition<f64>,
2836    scale_factor: f64,
2837) -> Vector {
2838    let logical = position.to_logical::<f32>(scale_factor);
2839    Vector::new(logical.x, logical.y)
2840}
2841
2842fn raw_mouse_motion_to_vector(delta: (f64, f64)) -> Vector {
2843    Vector::new(delta.0 as f32, delta.1 as f32)
2844}
2845
2846fn apply_ime_composition_rect(
2847    window: &Window,
2848    ime_allowed: &mut bool,
2849    rect: Option<sui_core::Rect>,
2850) {
2851    let cursor_area = rect.and_then(|rect| sanitize_ime_cursor_area(rect, window.scale_factor()));
2852    let next_ime_allowed = cursor_area.is_some();
2853    if next_ime_allowed != *ime_allowed {
2854        window.set_ime_allowed(next_ime_allowed);
2855        *ime_allowed = next_ime_allowed;
2856    }
2857
2858    if let Some((position, size)) = cursor_area {
2859        window.set_ime_cursor_area(position, size);
2860    }
2861}
2862
2863fn sanitize_ime_cursor_area(
2864    rect: sui_core::Rect,
2865    scale_factor: f64,
2866) -> Option<(PhysicalPosition<i32>, PhysicalSize<u32>)> {
2867    if !rect.x().is_finite()
2868        || !rect.y().is_finite()
2869        || !rect.width().is_finite()
2870        || !rect.height().is_finite()
2871    {
2872        return None;
2873    }
2874
2875    let scale_factor = if scale_factor.is_finite() && scale_factor > 0.0 {
2876        scale_factor
2877    } else {
2878        1.0
2879    };
2880    let position = LogicalPosition::new(rect.x() as f64, rect.y() as f64);
2881    let size = LogicalSize::new(rect.width().max(1.0) as f64, rect.height().max(1.0) as f64);
2882    let PhysicalPosition { x, y } = position.to_physical::<i32>(scale_factor);
2883    let PhysicalSize { width, height } = size.to_physical::<i32>(scale_factor);
2884    let x = x.min(i32::MAX - 1);
2885    let y = y.min(i32::MAX - 1);
2886    let max_width = ((i32::MAX as i64) - (x as i64)).clamp(1, i32::MAX as i64) as i32;
2887    let max_height = ((i32::MAX as i64) - (y as i64)).clamp(1, i32::MAX as i64) as i32;
2888    let width = width.clamp(1, max_width) as u32;
2889    let height = height.clamp(1, max_height) as u32;
2890
2891    Some((
2892        PhysicalPosition::new(x, y),
2893        PhysicalSize::new(width, height),
2894    ))
2895}
2896
2897fn modifiers_state_to_modifiers(state: ModifiersState) -> Modifiers {
2898    Modifiers {
2899        shift: state.shift_key(),
2900        control: state.control_key(),
2901        alt: state.alt_key(),
2902        meta: state.super_key(),
2903    }
2904}
2905
2906fn map_mouse_button(button: MouseButton) -> Option<PointerButton> {
2907    match button {
2908        MouseButton::Left => Some(PointerButton::Primary),
2909        MouseButton::Right => Some(PointerButton::Secondary),
2910        MouseButton::Middle => Some(PointerButton::Middle),
2911        MouseButton::Back => Some(PointerButton::Back),
2912        MouseButton::Forward => Some(PointerButton::Forward),
2913        MouseButton::Other(value) => Some(PointerButton::Other(value)),
2914    }
2915}
2916
2917fn remove_pointer_button(buttons: PointerButtons, removed: PointerButton) -> PointerButtons {
2918    let mut next = PointerButtons::NONE;
2919
2920    for button in [
2921        PointerButton::Primary,
2922        PointerButton::Secondary,
2923        PointerButton::Middle,
2924        PointerButton::Back,
2925        PointerButton::Forward,
2926    ] {
2927        if button != removed && buttons.contains(button) {
2928            next.insert(button);
2929        }
2930    }
2931
2932    next
2933}
2934
2935#[cfg(any(target_arch = "wasm32", test))]
2936fn web_click_semantics_action(
2937    node: &sui_core::SemanticsNode,
2938) -> Option<sui_core::SemanticsActionRequest> {
2939    use sui_core::{SemanticsAction, SemanticsActionRequest};
2940
2941    if node.actions.contains(&SemanticsAction::Activate) {
2942        Some(SemanticsActionRequest::Activate)
2943    } else if node.state.expanded == Some(false) && node.actions.contains(&SemanticsAction::Expand)
2944    {
2945        Some(SemanticsActionRequest::Expand)
2946    } else if node.state.expanded == Some(true) && node.actions.contains(&SemanticsAction::Collapse)
2947    {
2948        Some(SemanticsActionRequest::Collapse)
2949    } else if node.actions.contains(&SemanticsAction::Copy) {
2950        Some(SemanticsActionRequest::Copy)
2951    } else {
2952        None
2953    }
2954}
2955
2956#[cfg(target_arch = "wasm32")]
2957fn center(bounds: sui_core::Rect) -> Point {
2958    Point::new(
2959        bounds.x() + (bounds.width() * 0.5),
2960        bounds.y() + (bounds.height() * 0.5),
2961    )
2962}
2963
2964fn logical_key_to_string(key: &Key) -> String {
2965    match key {
2966        Key::Character(text) => text.to_string(),
2967        Key::Named(named) => named_key_to_string(*named),
2968        _ => format!("{key:?}"),
2969    }
2970}
2971
2972fn normalize_android_back_event(
2973    key: &Key,
2974    state: ElementState,
2975    repeat: bool,
2976    down_seen: &mut bool,
2977) -> (ElementState, bool) {
2978    if !matches!(key, Key::Named(NamedKey::BrowserBack)) {
2979        return (state, false);
2980    }
2981
2982    match state {
2983        ElementState::Pressed => {
2984            if !repeat {
2985                *down_seen = true;
2986            }
2987            (state, !repeat)
2988        }
2989        ElementState::Released if std::mem::take(down_seen) => (state, false),
2990        // Android's input queue lets the active IME pre-dispatch Back. Some IMEs consume
2991        // the Down edge and return only Up to the app, so normalize that release-only
2992        // sequence into the single activation expected by the runtime and window host.
2993        ElementState::Released => (ElementState::Pressed, !repeat),
2994    }
2995}
2996
2997fn named_key_to_string(key: NamedKey) -> String {
2998    match key {
2999        NamedKey::Enter => "Enter".to_string(),
3000        NamedKey::Space => " ".to_string(),
3001        NamedKey::Tab => "Tab".to_string(),
3002        NamedKey::Escape => "Escape".to_string(),
3003        NamedKey::ArrowDown => "ArrowDown".to_string(),
3004        NamedKey::ArrowLeft => "ArrowLeft".to_string(),
3005        NamedKey::ArrowRight => "ArrowRight".to_string(),
3006        NamedKey::ArrowUp => "ArrowUp".to_string(),
3007        _ => format!("{key:?}"),
3008    }
3009}
3010
3011fn physical_key_to_string(key: &PhysicalKey) -> String {
3012    match key {
3013        PhysicalKey::Code(code) => format!("{code:?}"),
3014        PhysicalKey::Unidentified(native_key) => format!("{native_key:?}"),
3015    }
3016}
3017
3018fn map_ime_event(event: Ime) -> Option<ImeEvent> {
3019    match event {
3020        Ime::Enabled => Some(ImeEvent::CompositionStart),
3021        Ime::Preedit(text, cursor_range) => Some(ImeEvent::CompositionUpdate {
3022            text,
3023            cursor_range: cursor_range.map(|(start, end)| start..end),
3024        }),
3025        Ime::Commit(text) => Some(ImeEvent::CompositionCommit { text }),
3026        Ime::Disabled => Some(ImeEvent::CompositionEnd),
3027    }
3028}
3029
3030fn map_external_file_window_event(event: &WinitWindowEvent) -> Option<WindowEvent> {
3031    match event {
3032        WinitWindowEvent::HoveredFile(path) => Some(WindowEvent::ExternalFileHovered(path.clone())),
3033        WinitWindowEvent::HoveredFileCancelled => Some(WindowEvent::ExternalFileHoverCancelled),
3034        WinitWindowEvent::DroppedFile(path) => Some(WindowEvent::ExternalFileDropped(path.clone())),
3035        _ => None,
3036    }
3037}
3038
3039#[cfg(not(target_arch = "wasm32"))]
3040fn window_icon_to_winit_icon(icon: &RuntimeWindowIcon) -> Result<WinitIcon> {
3041    match icon {
3042        RuntimeWindowIcon::Svg { data } => svg_window_icon_to_winit_icon(data),
3043        RuntimeWindowIcon::Rgba8 {
3044            width,
3045            height,
3046            data,
3047        } => WinitIcon::from_rgba(data.to_vec(), *width, *height).map_err(map_icon_error),
3048    }
3049}
3050
3051#[cfg(not(target_arch = "wasm32"))]
3052fn svg_window_icon_to_winit_icon(svg: &[u8]) -> Result<WinitIcon> {
3053    let (width, height, rgba) = rasterize_svg_window_icon_rgba8(svg, DEFAULT_WINDOW_ICON_SIZE)?;
3054    WinitIcon::from_rgba(rgba, width, height).map_err(map_icon_error)
3055}
3056
3057#[cfg(not(target_arch = "wasm32"))]
3058fn rasterize_svg_window_icon_rgba8(svg: &[u8], size: u32) -> Result<(u32, u32, Vec<u8>)> {
3059    if size == 0 {
3060        return Err(Error::new("window icon bitmap size must be non-zero"));
3061    }
3062    let options = resvg::usvg::Options::default();
3063    let tree = resvg::usvg::Tree::from_data(svg, &options)
3064        .map_err(|error| Error::new(format!("failed to parse window icon SVG: {error}")))?;
3065    let source_size = tree.size();
3066    let scale = (size as f32 / source_size.width()).min(size as f32 / source_size.height());
3067    let offset_x = (size as f32 - source_size.width() * scale) * 0.5;
3068    let offset_y = (size as f32 - source_size.height() * scale) * 0.5;
3069    let transform =
3070        resvg::tiny_skia::Transform::from_translate(offset_x, offset_y).pre_scale(scale, scale);
3071
3072    let mut pixmap = resvg::tiny_skia::Pixmap::new(size, size)
3073        .ok_or_else(|| Error::new("failed to allocate window icon bitmap"))?;
3074    resvg::render(&tree, transform, &mut pixmap.as_mut());
3075
3076    let mut rgba = Vec::with_capacity((size * size * 4) as usize);
3077    for pixel in pixmap.pixels() {
3078        let color = pixel.demultiply();
3079        rgba.extend_from_slice(&[color.red(), color.green(), color.blue(), color.alpha()]);
3080    }
3081
3082    Ok((size, size, rgba))
3083}
3084
3085#[cfg(not(target_arch = "wasm32"))]
3086fn map_icon_error(error: winit::window::BadIcon) -> Error {
3087    Error::new(format!("failed to create window icon: {error}"))
3088}
3089
3090#[cfg(target_arch = "wasm32")]
3091fn install_web_favicon(icon: Option<&RuntimeWindowIcon>) -> Result<()> {
3092    let Some(document) = web_sys::window().and_then(|window| window.document()) else {
3093        return Ok(());
3094    };
3095    let Some(head) = document.head() else {
3096        return Ok(());
3097    };
3098
3099    remove_web_icon_link(&document, WEB_LEGACY_FAVICON_ID);
3100    let Some(RuntimeWindowIcon::Svg { data }) = icon else {
3101        remove_web_icon_links(&document);
3102        return Ok(());
3103    };
3104
3105    let svg_url = svg_favicon_data_url(data);
3106    install_web_icon_link(
3107        &document,
3108        &head,
3109        WEB_SVG_FAVICON_ID,
3110        "icon",
3111        "image/svg+xml",
3112        "any",
3113        &svg_url,
3114    )?;
3115    install_web_png_icon(
3116        &document,
3117        &head,
3118        data,
3119        WEB_PNG_FAVICON_ID,
3120        "icon",
3121        "64x64",
3122        64,
3123    );
3124    install_web_png_icon(
3125        &document,
3126        &head,
3127        data,
3128        WEB_APPLE_TOUCH_ICON_ID,
3129        "apple-touch-icon",
3130        "180x180",
3131        180,
3132    );
3133    Ok(())
3134}
3135
3136#[cfg(target_arch = "wasm32")]
3137fn install_web_icon_link(
3138    document: &web_sys::Document,
3139    head: &web_sys::HtmlHeadElement,
3140    id: &str,
3141    rel: &str,
3142    mime_type: &str,
3143    sizes: &str,
3144    href: &str,
3145) -> Result<()> {
3146    let link = if let Some(link) = document.get_element_by_id(id) {
3147        link
3148    } else {
3149        let link = document
3150            .create_element("link")
3151            .map_err(|_| Error::new("failed to create web icon link element"))?;
3152        link.set_attribute("id", id)
3153            .map_err(|_| Error::new("failed to configure web icon id"))?;
3154        head.append_child(&link)
3155            .map_err(|_| Error::new("failed to attach web icon link"))?;
3156        link
3157    };
3158
3159    link.set_attribute("rel", rel)
3160        .map_err(|_| Error::new("failed to configure web icon rel"))?;
3161    link.set_attribute("type", mime_type)
3162        .map_err(|_| Error::new("failed to configure web icon type"))?;
3163    if sizes.is_empty() {
3164        link.remove_attribute("sizes")
3165            .map_err(|_| Error::new("failed to clear web icon sizes"))?;
3166    } else {
3167        link.set_attribute("sizes", sizes)
3168            .map_err(|_| Error::new("failed to configure web icon sizes"))?;
3169    }
3170    link.set_attribute("href", href)
3171        .map_err(|_| Error::new("failed to configure web icon href"))
3172}
3173
3174#[cfg(target_arch = "wasm32")]
3175fn remove_web_icon_links(document: &web_sys::Document) {
3176    remove_web_icon_link(document, WEB_SVG_FAVICON_ID);
3177    remove_web_icon_link(document, WEB_PNG_FAVICON_ID);
3178    remove_web_icon_link(document, WEB_APPLE_TOUCH_ICON_ID);
3179}
3180
3181#[cfg(target_arch = "wasm32")]
3182fn remove_web_icon_link(document: &web_sys::Document, id: &str) {
3183    let Some(link) = document.get_element_by_id(id) else {
3184        return;
3185    };
3186    let Some(parent) = link.parent_node() else {
3187        return;
3188    };
3189    let _ = parent.remove_child(&link);
3190}
3191
3192#[cfg(target_arch = "wasm32")]
3193fn svg_favicon_data_url(svg: &[u8]) -> String {
3194    const HEX: &[u8; 16] = b"0123456789ABCDEF";
3195
3196    let mut url = String::from("data:image/svg+xml;charset=utf-8,");
3197    for byte in svg {
3198        match *byte {
3199            b'A'..=b'Z' | b'a'..=b'z' | b'0'..=b'9' | b'-' | b'_' | b'.' | b'~' => {
3200                url.push(*byte as char)
3201            }
3202            byte => {
3203                url.push('%');
3204                url.push(HEX[(byte >> 4) as usize] as char);
3205                url.push(HEX[(byte & 0x0f) as usize] as char);
3206            }
3207        }
3208    }
3209    url
3210}
3211
3212#[cfg(target_arch = "wasm32")]
3213fn install_web_png_icon(
3214    document: &web_sys::Document,
3215    head: &web_sys::HtmlHeadElement,
3216    svg: &[u8],
3217    link_id: &str,
3218    rel: &str,
3219    sizes: &str,
3220    size: u32,
3221) {
3222    use wasm_bindgen::closure::Closure;
3223
3224    let Ok(canvas_element) = document.create_element("canvas") else {
3225        return;
3226    };
3227    let Ok(canvas) = canvas_element.dyn_into::<web_sys::HtmlCanvasElement>() else {
3228        return;
3229    };
3230    canvas.set_width(size);
3231    canvas.set_height(size);
3232
3233    let Ok(Some(context)) = canvas.get_context("2d") else {
3234        return;
3235    };
3236    let Ok(context) = context.dyn_into::<web_sys::CanvasRenderingContext2d>() else {
3237        return;
3238    };
3239    let Ok(image) = web_sys::HtmlImageElement::new() else {
3240        return;
3241    };
3242
3243    let svg_url = svg_favicon_data_url(svg);
3244    let document = document.clone();
3245    let head = head.clone();
3246    let link_id = link_id.to_string();
3247    let rel = rel.to_string();
3248    let sizes = sizes.to_string();
3249    let image_for_load = image.clone();
3250    let onload = Closure::<dyn FnMut()>::new(move || {
3251        let size = size as f64;
3252        context.clear_rect(0.0, 0.0, size, size);
3253        if context
3254            .draw_image_with_html_image_element_and_dw_and_dh(&image_for_load, 0.0, 0.0, size, size)
3255            .is_ok()
3256            && let Ok(png_url) = canvas.to_data_url_with_type("image/png")
3257        {
3258            let _ = install_web_icon_link(
3259                &document,
3260                &head,
3261                &link_id,
3262                &rel,
3263                "image/png",
3264                &sizes,
3265                &png_url,
3266            );
3267        }
3268    });
3269
3270    image.set_onload(Some(onload.as_ref().unchecked_ref()));
3271    image.set_src(&svg_url);
3272    onload.forget();
3273}
3274
3275fn map_event_loop_error(error: EventLoopError) -> Error {
3276    Error::new(format!("winit event loop error: {error}"))
3277}
3278
3279fn map_os_error(error: OsError) -> Error {
3280    Error::new(format!("failed to create desktop window: {error}"))
3281}
3282
3283#[cfg(test)]
3284mod tests {
3285    use std::path::PathBuf;
3286
3287    use super::{
3288        HostLifecycle, apply_cursor_grab_with, map_external_file_window_event,
3289        normalize_android_back_event, physical_position_to_logical_point,
3290        physical_position_to_logical_vector, physical_size_to_logical_size,
3291        rasterize_svg_window_icon_rgba8, raw_mouse_motion_to_vector, sanitize_ime_cursor_area,
3292        web_click_semantics_action, window_icon_to_winit_icon,
3293    };
3294    use sui_core::{
3295        CursorGrabMode, Rect, SemanticsAction, SemanticsActionRequest, SemanticsNode,
3296        SemanticsRole, WindowEvent,
3297    };
3298    use sui_runtime::WindowIcon;
3299    use winit::dpi::{PhysicalPosition, PhysicalSize};
3300    use winit::{
3301        event::{ElementState, WindowEvent as WinitWindowEvent},
3302        keyboard::{Key, NamedKey},
3303        window::CursorGrabMode as WinitCursorGrabMode,
3304    };
3305
3306    #[test]
3307    fn host_lifecycle_waits_for_resume_and_handles_redundant_callbacks() {
3308        let mut lifecycle = HostLifecycle::default();
3309
3310        assert!(!lifecycle.is_resumed());
3311        assert!(!lifecycle.suspend());
3312        assert!(lifecycle.resume());
3313        assert!(lifecycle.is_resumed());
3314        assert!(!lifecycle.resume());
3315        assert!(lifecycle.suspend());
3316        assert!(!lifecycle.is_resumed());
3317        assert!(!lifecycle.suspend());
3318        assert!(lifecycle.resume());
3319    }
3320
3321    #[test]
3322    fn locked_cursor_grab_falls_back_to_confined_then_releases() {
3323        let mut attempts = Vec::new();
3324        let applied = apply_cursor_grab_with(CursorGrabMode::Locked, |mode| {
3325            attempts.push(mode);
3326            match mode {
3327                WinitCursorGrabMode::Locked => Err(()),
3328                WinitCursorGrabMode::Confined => Ok(()),
3329                WinitCursorGrabMode::None => Ok(()),
3330            }
3331        });
3332        assert_eq!(applied, CursorGrabMode::Confined);
3333        assert_eq!(
3334            attempts,
3335            [WinitCursorGrabMode::Locked, WinitCursorGrabMode::Confined]
3336        );
3337
3338        attempts.clear();
3339        let applied = apply_cursor_grab_with(CursorGrabMode::Locked, |mode| {
3340            attempts.push(mode);
3341            (mode == WinitCursorGrabMode::None).then_some(()).ok_or(())
3342        });
3343        assert_eq!(applied, CursorGrabMode::None);
3344        assert_eq!(
3345            attempts,
3346            [
3347                WinitCursorGrabMode::Locked,
3348                WinitCursorGrabMode::Confined,
3349                WinitCursorGrabMode::None
3350            ]
3351        );
3352    }
3353
3354    #[test]
3355    fn converts_physical_size_to_logical_size() {
3356        let size = physical_size_to_logical_size(PhysicalSize::new(640, 360), 2.0);
3357
3358        assert_eq!(size.width, 320.0);
3359        assert_eq!(size.height, 180.0);
3360    }
3361
3362    #[test]
3363    fn converts_physical_pointer_position_to_logical_point() {
3364        let point = physical_position_to_logical_point(PhysicalPosition::new(240.0, 120.0), 1.5);
3365
3366        assert_eq!(point.x, 160.0);
3367        assert_eq!(point.y, 80.0);
3368    }
3369
3370    #[test]
3371    fn converts_physical_scroll_delta_to_logical_vector() {
3372        let delta = physical_position_to_logical_vector(PhysicalPosition::new(90.0, 45.0), 1.5);
3373
3374        assert_eq!(delta.x, 60.0);
3375        assert_eq!(delta.y, 30.0);
3376    }
3377
3378    #[test]
3379    fn preserves_raw_mouse_motion_without_dpi_scaling() {
3380        let delta = raw_mouse_motion_to_vector((12.5, -7.25));
3381
3382        assert_eq!(delta.x, 12.5);
3383        assert_eq!(delta.y, -7.25);
3384    }
3385
3386    #[test]
3387    fn android_back_normalization_activates_once_for_press_and_release() {
3388        let browser_back = Key::Named(NamedKey::BrowserBack);
3389        let mut down_seen = false;
3390
3391        assert_eq!(
3392            normalize_android_back_event(
3393                &browser_back,
3394                ElementState::Pressed,
3395                false,
3396                &mut down_seen,
3397            ),
3398            (ElementState::Pressed, true)
3399        );
3400        assert!(down_seen);
3401        assert_eq!(
3402            normalize_android_back_event(
3403                &browser_back,
3404                ElementState::Released,
3405                false,
3406                &mut down_seen,
3407            ),
3408            (ElementState::Released, false)
3409        );
3410        assert!(!down_seen);
3411        assert_eq!(
3412            normalize_android_back_event(
3413                &browser_back,
3414                ElementState::Pressed,
3415                true,
3416                &mut down_seen,
3417            ),
3418            (ElementState::Pressed, false)
3419        );
3420        assert_eq!(
3421            normalize_android_back_event(
3422                &Key::Named(NamedKey::Escape),
3423                ElementState::Pressed,
3424                false,
3425                &mut down_seen,
3426            ),
3427            (ElementState::Pressed, false)
3428        );
3429    }
3430
3431    #[test]
3432    fn android_back_normalization_promotes_release_only_delivery() {
3433        let mut down_seen = false;
3434        assert_eq!(
3435            normalize_android_back_event(
3436                &Key::Named(NamedKey::BrowserBack),
3437                ElementState::Released,
3438                false,
3439                &mut down_seen,
3440            ),
3441            (ElementState::Pressed, true)
3442        );
3443        assert!(!down_seen);
3444    }
3445
3446    #[test]
3447    fn web_click_prefers_advertised_non_geometric_semantics_actions() {
3448        let mut node = SemanticsNode::new(
3449            sui_core::WidgetId::new(7),
3450            SemanticsRole::Status,
3451            Rect::new(0.0, 0.0, 120.0, 32.0),
3452        );
3453        node.state.expanded = Some(false);
3454        node.actions.push(SemanticsAction::Expand);
3455        assert_eq!(
3456            web_click_semantics_action(&node),
3457            Some(SemanticsActionRequest::Expand)
3458        );
3459
3460        node.state.expanded = Some(true);
3461        node.actions = vec![SemanticsAction::Collapse];
3462        assert_eq!(
3463            web_click_semantics_action(&node),
3464            Some(SemanticsActionRequest::Collapse)
3465        );
3466
3467        node.state.expanded = None;
3468        node.actions = vec![SemanticsAction::Copy];
3469        assert_eq!(
3470            web_click_semantics_action(&node),
3471            Some(SemanticsActionRequest::Copy)
3472        );
3473    }
3474
3475    #[test]
3476    fn maps_winit_external_file_window_events() {
3477        let path = PathBuf::from(r"C:\workspace\agent.json");
3478
3479        assert_eq!(
3480            map_external_file_window_event(&WinitWindowEvent::HoveredFile(path.clone())),
3481            Some(WindowEvent::ExternalFileHovered(path.clone()))
3482        );
3483        assert_eq!(
3484            map_external_file_window_event(&WinitWindowEvent::DroppedFile(path.clone())),
3485            Some(WindowEvent::ExternalFileDropped(path))
3486        );
3487        assert_eq!(
3488            map_external_file_window_event(&WinitWindowEvent::HoveredFileCancelled),
3489            Some(WindowEvent::ExternalFileHoverCancelled)
3490        );
3491        assert_eq!(
3492            map_external_file_window_event(&WinitWindowEvent::Focused(true)),
3493            None
3494        );
3495    }
3496
3497    #[test]
3498    fn sanitize_ime_cursor_area_preserves_valid_geometry() {
3499        let (position, size) =
3500            sanitize_ime_cursor_area(Rect::new(10.0, 20.0, 4.0, 6.0), 1.5).unwrap();
3501
3502        assert_eq!(position, PhysicalPosition::new(15, 30));
3503        assert_eq!(size, PhysicalSize::new(6, 9));
3504    }
3505
3506    #[test]
3507    fn sanitize_ime_cursor_area_clamps_overflowing_geometry() {
3508        let (position, size) =
3509            sanitize_ime_cursor_area(Rect::new(f32::MAX, f32::MAX, f32::MAX, f32::MAX), 1.0)
3510                .unwrap();
3511
3512        assert_eq!(position, PhysicalPosition::new(i32::MAX - 1, i32::MAX - 1));
3513        assert_eq!(size, PhysicalSize::new(1, 1));
3514    }
3515
3516    #[test]
3517    fn sanitize_ime_cursor_area_rejects_non_finite_geometry() {
3518        assert!(sanitize_ime_cursor_area(Rect::new(f32::NAN, 0.0, 10.0, 10.0), 1.0).is_none());
3519        assert!(sanitize_ime_cursor_area(Rect::new(0.0, 0.0, f32::INFINITY, 10.0), 1.0).is_none());
3520    }
3521
3522    #[test]
3523    fn default_svg_window_icon_rasterizes_to_winit_icon() {
3524        assert!(window_icon_to_winit_icon(&WindowIcon::sui()).is_ok());
3525    }
3526
3527    #[test]
3528    fn default_svg_window_icon_rasterizes_to_bitmap() {
3529        let (width, height, rgba) =
3530            rasterize_svg_window_icon_rgba8(WindowIcon::sui().as_svg().unwrap(), 64).unwrap();
3531
3532        assert_eq!((width, height), (64, 64));
3533        assert_eq!(rgba.len(), 64 * 64 * 4);
3534        assert!(rgba.as_chunks::<4>().0.iter().any(|pixel| pixel[3] != 0));
3535    }
3536}