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