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