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