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