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