Skip to main content

sui_platform/
desktop.rs

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