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 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 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 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 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 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 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#[derive(Debug, Clone, Copy)]
1902pub struct WakeSignal;
1903
1904#[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 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}