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