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