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.host_lifecycle.is_resumed() {
1027 event_loop.set_control_flow(ControlFlow::Wait);
1028 return Ok(());
1029 }
1030
1031 self.sync_windows(event_loop)?;
1032 if self.windows.is_empty() {
1033 return Ok(());
1034 }
1035
1036 self.update_clock();
1037 self.runtime.tick(self.frame_clock);
1038
1039 while self.dispatch_ready_events(event_loop)? {}
1040
1041 self.sync_windows(event_loop)?;
1042
1043 self.sync_extensions()?;
1044
1045 #[cfg(target_arch = "wasm32")]
1046 self.process_web_interop_commands(event_loop)?;
1047
1048 let window_ids: Vec<_> = self.windows.keys().copied().collect();
1049 for window_id in window_ids.iter().copied() {
1050 self.sync_frame_pacing(window_id)?;
1051 self.request_redraw_if_needed(window_id)?;
1052 }
1053
1054 self.drive_automation(event_loop)?;
1055 if self
1056 .automation
1057 .as_ref()
1058 .is_some_and(|automation| automation.shutdown_requested)
1059 {
1060 let window_ids = self.runtime.window_ids();
1061 for window_id in window_ids {
1062 self.runtime.remove_window(window_id)?;
1063 crate::clear_window_performance(window_id);
1064 }
1065 self.sync_windows(event_loop)?;
1066 return Ok(());
1067 }
1068
1069 self.update_control_flow(event_loop)?;
1070 Ok(())
1071 }
1072
1073 fn dispatch_ready_events(&mut self, event_loop: &ActiveEventLoop) -> Result<bool> {
1074 let events = self.runtime.drain_ready_events();
1075 let had_events = !events.is_empty();
1076 for (window_id, event) in events {
1077 if self.windows.contains_key(&window_id) {
1078 self.process_event(event_loop, window_id, event)?;
1079 }
1080 }
1081 Ok(had_events)
1082 }
1083
1084 fn sync_frame_pacing(&mut self, window_id: WindowId) -> Result<()> {
1088 let vsync = self.renderer.vsync_enabled();
1089 let Some(window) = self.windows.get_mut(&window_id) else {
1090 return Ok(());
1091 };
1092 let size = window.window.inner_size();
1093 let presenting = !window.occluded
1094 && window.window.is_minimized() != Some(true)
1095 && size.width > 0
1096 && size.height > 0;
1097 let pacing = if vsync && presenting {
1098 FramePacing::Display
1099 } else {
1100 FramePacing::Timer
1101 };
1102 if window.frame_pacing != pacing {
1103 window.frame_pacing = pacing;
1104 window.cadence = FrameCadence::default();
1105 self.runtime.set_frame_pacing(window_id, pacing)?;
1106 }
1107 Ok(())
1108 }
1109
1110 fn begin_display_paced_frame(
1113 &mut self,
1114 event_loop: &ActiveEventLoop,
1115 window_id: WindowId,
1116 ) -> Result<()> {
1117 let now = self.frame_clock;
1118 let Some(window) = self.windows.get_mut(&window_id) else {
1119 return Ok(());
1120 };
1121 if window.frame_pacing != FramePacing::Display
1122 || !self.runtime.has_pending_animation_frames(window_id)?
1123 {
1124 return Ok(());
1125 }
1126 let frame_time = window.cadence.next(now, window.refresh_interval);
1127 for event in self.runtime.begin_animation_frame(window_id, frame_time)? {
1128 self.process_event(event_loop, window_id, event)?;
1129 }
1130 Ok(())
1131 }
1132
1133 fn request_redraw_if_needed(&mut self, window_id: WindowId) -> Result<()> {
1134 let keep_presenting = self.renderer.vsync_enabled()
1138 && self
1139 .windows
1140 .get(&window_id)
1141 .is_some_and(|window| window.focused);
1142 let animating = self
1145 .windows
1146 .get(&window_id)
1147 .is_some_and(|window| window.frame_pacing == FramePacing::Display)
1148 && self.runtime.has_pending_animation_frames(window_id)?;
1149 let capturing = crate::has_pending_window_debug_captures(window_id);
1150 if !self.runtime.needs_render(window_id)? && !keep_presenting && !animating && !capturing {
1151 return Ok(());
1152 }
1153
1154 let now_ms = self.current_time_ms();
1155
1156 let Some(window) = self.windows.get_mut(&window_id) else {
1157 return Ok(());
1158 };
1159
1160 let size = window.window.inner_size();
1161 if window.occluded
1162 || window.window.is_minimized() == Some(true)
1163 || size.width == 0
1164 || size.height == 0
1165 {
1166 return Ok(());
1167 }
1168 if window.redraw_requested {
1169 return Ok(());
1170 }
1171
1172 window.redraw_requested = true;
1173 window.redraw_requested_at_ms = Some(now_ms);
1174 window.window.request_redraw();
1175 Ok(())
1176 }
1177
1178 fn update_clock(&mut self) {
1179 self.frame_clock = self.started_at.elapsed().as_secs_f64();
1180 }
1181
1182 fn current_time_ms(&self) -> f64 {
1183 self.started_at.elapsed().as_secs_f64() * 1000.0
1184 }
1185
1186 fn update_control_flow(&self, event_loop: &ActiveEventLoop) -> Result<()> {
1187 if self.windows.is_empty() {
1188 event_loop.exit();
1189 return Ok(());
1190 }
1191
1192 let mut next_deadline: Option<f64> = None;
1193
1194 for window_id in self.runtime.window_ids() {
1195 let deadline = self.runtime.next_wakeup_time(window_id)?;
1196 next_deadline = match (next_deadline, deadline) {
1197 (Some(current), Some(candidate)) => Some(current.min(candidate)),
1198 (None, Some(candidate)) => Some(candidate),
1199 (current, None) => current,
1200 };
1201 }
1202
1203 if let Some(automation_deadline) = self
1204 .automation
1205 .as_ref()
1206 .and_then(DesktopAutomationState::next_deadline)
1207 {
1208 let candidate = (automation_deadline - self.started_at).as_secs_f64();
1209 next_deadline = match next_deadline {
1210 Some(current) => Some(current.min(candidate)),
1211 None => Some(candidate),
1212 };
1213 }
1214
1215 if let Some(interval) = self
1216 .extensions
1217 .iter()
1218 .filter_map(|extension| extension.poll_interval())
1219 .min()
1220 {
1221 let candidate = self.frame_clock + interval.as_secs_f64();
1222 next_deadline = match next_deadline {
1223 Some(current) => Some(current.min(candidate)),
1224 None => Some(candidate),
1225 };
1226 }
1227
1228 match next_deadline {
1229 Some(deadline) if deadline <= self.frame_clock => {
1230 event_loop.set_control_flow(ControlFlow::Poll);
1231 }
1232 Some(deadline) => {
1233 let when = self.started_at + Duration::from_secs_f64(deadline.max(0.0));
1234 event_loop.set_control_flow(ControlFlow::WaitUntil(when));
1235 }
1236 None => event_loop.set_control_flow(ControlFlow::Wait),
1237 }
1238
1239 Ok(())
1240 }
1241
1242 fn process_event(
1243 &mut self,
1244 event_loop: &ActiveEventLoop,
1245 window_id: WindowId,
1246 event: Event,
1247 ) -> Result<()> {
1248 self.process_event_with_outcome(event_loop, window_id, event)
1249 .map(|_| ())
1250 }
1251
1252 fn process_event_with_outcome(
1253 &mut self,
1254 event_loop: &ActiveEventLoop,
1255 window_id: WindowId,
1256 event: Event,
1257 ) -> Result<bool> {
1258 if !self.windows.contains_key(&window_id) {
1259 return Ok(false);
1260 }
1261
1262 let event_arrived_at_ms = self.current_time_ms();
1263
1264 let is_redraw = matches!(event, Event::Window(WindowEvent::RedrawRequested));
1265 let is_close = matches!(event, Event::Window(WindowEvent::CloseRequested));
1266
1267 self.update_clock();
1271 self.runtime.tick(self.frame_clock);
1272
1273 if is_redraw {
1274 self.dispatch_ready_events(event_loop)?;
1279 self.begin_display_paced_frame(event_loop, window_id)?;
1280 }
1281
1282 let event_started = Instant::now();
1283 let handled = self.runtime.dispatch_event(window_id, event)?;
1284 let event_time_ms = event_started.elapsed().as_secs_f64() * 1000.0;
1285
1286 self.sync_window_cursor(window_id)?;
1287
1288 if !is_redraw
1292 && !is_close
1293 && self.runtime.needs_render(window_id)?
1294 && let Some(window) = self.windows.get_mut(&window_id)
1295 {
1296 window.pending_event_time_ms += event_time_ms;
1297 window.last_non_redraw_event_at_ms = Some(event_arrived_at_ms);
1298 }
1299
1300 if !is_redraw && !is_close {
1301 self.request_redraw_if_needed(window_id)?;
1302 }
1303
1304 if is_redraw {
1313 if let Some(window) = self.windows.get_mut(&window_id) {
1314 window.redraw_requested = false;
1315 }
1316
1317 self.render_window_if_needed(window_id, event_time_ms)?;
1318 self.service_debug_captures(window_id)?;
1319 self.request_redraw_if_needed(window_id)?;
1322 }
1323
1324 if is_close {
1325 if let Some(window) = self.windows.get_mut(&window_id) {
1326 release_host_cursor(window);
1327 }
1328 self.runtime.remove_window(window_id)?;
1329 crate::clear_window_performance(window_id);
1330 self.sync_windows(event_loop)?;
1331 self.sync_extensions()?;
1332 }
1333
1334 if self.windows.is_empty() {
1335 event_loop.exit();
1336 }
1337
1338 Ok(handled)
1339 }
1340
1341 fn sync_window_cursor(&mut self, window_id: WindowId) -> Result<()> {
1342 let desired = self.runtime.window_cursor_state(window_id)?;
1343 let Some(window) = self.windows.get_mut(&window_id) else {
1344 return Ok(());
1345 };
1346 if window.applied_cursor_revision == desired.revision {
1347 return Ok(());
1348 }
1349
1350 let requested_grab = if window.focused {
1351 desired.grab_mode
1352 } else {
1353 CursorGrabMode::None
1354 };
1355 window.applied_cursor_grab = apply_host_cursor_grab(window.window.as_ref(), requested_grab);
1356 window
1357 .window
1358 .set_cursor_visible(desired.visible || !window.focused);
1359 window.applied_cursor_revision = desired.revision;
1360 Ok(())
1361 }
1362
1363 fn service_debug_captures(&mut self, window_id: WindowId) -> Result<()> {
1366 for token in crate::service_window_debug_captures(&mut self.renderer, window_id) {
1367 self.runtime.wake_async(window_id, token)?;
1368 }
1369 Ok(())
1370 }
1371
1372 fn render_window_if_needed(&mut self, window_id: WindowId, event_time_ms: f64) -> Result<()> {
1373 if self.windows.get(&window_id).is_none_or(|host| {
1376 let size = host.window.inner_size();
1377 host.occluded
1378 || host.window.is_minimized() == Some(true)
1379 || size.width == 0
1380 || size.height == 0
1381 }) {
1382 return Ok(());
1383 }
1384 if !self.runtime.needs_render(window_id)? {
1385 return Ok(());
1386 }
1387
1388 self.update_clock();
1389 self.runtime.tick(self.frame_clock);
1390
1391 let render_started_at_ms = self.current_time_ms();
1392 let mut presentation_latency = PresentationLatencyDiagnostics::default();
1393 if let Some(window) = self.windows.get(&window_id) {
1394 presentation_latency = PresentationLatencyDiagnostics::new(
1395 window
1396 .last_non_redraw_event_at_ms
1397 .map(|timestamp| (render_started_at_ms - timestamp).max(0.0))
1398 .unwrap_or(0.0),
1399 0.0,
1400 window
1401 .redraw_requested_at_ms
1402 .map(|timestamp| (render_started_at_ms - timestamp).max(0.0))
1403 .unwrap_or(0.0),
1404 );
1405 }
1406
1407 if self
1408 .windows
1409 .get(&window_id)
1410 .is_some_and(|window| window.display_capabilities_dirty)
1411 {
1412 self.refresh_window_display_capabilities(window_id)?;
1413 if let Some(window) = self.windows.get_mut(&window_id) {
1414 window.display_capabilities_dirty = false;
1415 }
1416 }
1417 let PresentedFrame {
1418 output,
1419 runtime_time_ms,
1420 renderer_time_ms,
1421 presented_at,
1422 } = present_window_frame(&mut self.runtime, &mut self.renderer, window_id)?;
1423 self.sync_window_cursor(window_id)?;
1427 let semantics = output.semantics.clone();
1428 let presented_at = (!self.extensions.is_empty()).then_some(presented_at);
1429 let presented_at_ms = self.current_time_ms();
1430 if let Some(window) = self.windows.get(&window_id) {
1431 presentation_latency.event_to_present_ms = window
1432 .last_non_redraw_event_at_ms
1433 .map(|timestamp| (presented_at_ms - timestamp).max(0.0))
1434 .unwrap_or(0.0);
1435 }
1436
1437 let mut frame_index = 0;
1438 let mut pending_event_time_ms = 0.0;
1439
1440 if let Some(window) = self.windows.get_mut(&window_id) {
1441 frame_index = window.frame_index + 1;
1442 pending_event_time_ms = std::mem::take(&mut window.pending_event_time_ms);
1443 window.frame_index = frame_index;
1444
1445 if window.title != output.title {
1446 window.title = output.title.clone();
1447 window.window.set_title(&output.title);
1448 }
1449
1450 #[cfg(target_os = "windows")]
1451 {
1452 let scale_factor = window.scale_factor;
1453 let WindowState {
1454 accesskit_adapter,
1455 accesskit_snapshot,
1456 ..
1457 } = window;
1458 accesskit_adapter.update_if_active(|| {
1459 let snapshot = build_accesskit_snapshot(
1460 window_id,
1461 scale_factor,
1462 &output.title,
1463 &semantics,
1464 );
1465 let update = snapshot.full_update();
1466 *accesskit_snapshot = snapshot;
1467 update
1468 });
1469 }
1470
1471 window.accessibility.update(window_id, semantics);
1472 window.last_non_redraw_event_at_ms = None;
1473 window.redraw_requested_at_ms = None;
1474
1475 apply_ime_composition_rect(
1476 window.window.as_ref(),
1477 &mut window.ime_allowed,
1478 output.ime_composition_rect,
1479 );
1480 }
1481
1482 crate::publish_frame_performance(
1483 window_id,
1484 frame_index,
1485 pending_event_time_ms,
1486 event_time_ms,
1487 runtime_time_ms,
1488 presentation_latency,
1489 &output,
1490 &self.renderer,
1491 renderer_time_ms,
1492 );
1493
1494 if let Some(presented_at) = presented_at {
1495 let commands = self.runtime.command_sender();
1496 for extension in &mut self.extensions {
1497 extension.frame_presented(
1498 DesktopExtensionContext {
1499 runtime: &self.runtime,
1500 renderer: &self.renderer,
1501 windows: &self.windows,
1502 commands: &commands,
1503 },
1504 DesktopFramePresented {
1505 window_id,
1506 frame_index,
1507 presented_at,
1508 runtime_duration: Duration::from_secs_f64(runtime_time_ms / 1000.0),
1509 },
1510 )?;
1511 }
1512 }
1513
1514 #[cfg(target_arch = "wasm32")]
1515 if let Some(window) = self.windows.get(&window_id) {
1516 let performance = window_performance_snapshot(window_id);
1517 crate::web_interop::publish_snapshot(
1518 window_id,
1519 frame_index,
1520 window.scale_factor,
1521 output.frame.viewport,
1522 &output.semantics,
1523 performance.as_ref(),
1524 );
1525 }
1526
1527 let bootstrap_redraw_at_ms = self.current_time_ms();
1528 if let Some(window) = self.windows.get_mut(&window_id)
1529 && window.awaiting_performance_bootstrap
1530 {
1531 window.awaiting_performance_bootstrap = false;
1532 if !window.redraw_requested {
1533 window.redraw_requested = true;
1534 window.redraw_requested_at_ms = Some(bootstrap_redraw_at_ms);
1535 window.window.request_redraw();
1536 }
1537 }
1538
1539 Ok(())
1540 }
1541
1542 fn handle_window_event(
1543 &mut self,
1544 event_loop: &ActiveEventLoop,
1545 host_id: HostWindowId,
1546 event: WinitWindowEvent,
1547 ) -> Result<()> {
1548 let Some(window_id) = self.host_to_runtime.get(&host_id).copied() else {
1549 return Ok(());
1550 };
1551
1552 #[cfg(target_os = "windows")]
1553 if let Some(window) = self.windows.get_mut(&window_id) {
1554 window
1557 .accesskit_adapter
1558 .process_event(window.window.as_ref(), &event);
1559 }
1560
1561 if let Some(file_event) = map_external_file_window_event(&event) {
1562 return self.process_event(event_loop, window_id, Event::Window(file_event));
1563 }
1564
1565 match event {
1566 WinitWindowEvent::CloseRequested => self.process_event(
1567 event_loop,
1568 window_id,
1569 Event::Window(WindowEvent::CloseRequested),
1570 ),
1571 WinitWindowEvent::Resized(size) if size.width == 0 || size.height == 0 => Ok(()),
1574 WinitWindowEvent::Resized(size) => self.process_event(
1575 event_loop,
1576 window_id,
1577 Event::Window(WindowEvent::Resized(
1578 self.windows
1579 .get(&window_id)
1580 .map(|window| physical_size_to_logical_size(size, window.scale_factor))
1581 .unwrap_or_else(|| physical_size_to_logical_size(size, 1.0)),
1582 )),
1583 ),
1584 WinitWindowEvent::Moved(position) => {
1585 if let Some(window) = self.windows.get_mut(&window_id) {
1587 window.refresh_interval = monitor_refresh_interval(&window.window);
1588 }
1589 self.process_event(
1590 event_loop,
1591 window_id,
1592 Event::Window(WindowEvent::Moved(Point::new(
1593 position.x as f32,
1594 position.y as f32,
1595 ))),
1596 )
1597 }
1598 WinitWindowEvent::ScaleFactorChanged { scale_factor, .. } => {
1599 let suggested_size = self.windows.get_mut(&window_id).map(|window| {
1600 window.scale_factor = scale_factor;
1601 window.display_capabilities_dirty = true;
1602 window.refresh_interval = monitor_refresh_interval(&window.window);
1603 physical_size_to_logical_size(window.window.inner_size(), scale_factor)
1604 });
1605 self.process_event(
1606 event_loop,
1607 window_id,
1608 Event::Window(WindowEvent::ScaleFactorChanged {
1609 scale_factor,
1610 raw_dpi: None,
1611 suggested_size,
1612 }),
1613 )
1614 }
1615 WinitWindowEvent::Focused(focused) => {
1616 if focused {
1617 crate::motion_preference::sync_system_motion_preference();
1619 }
1620 if let Some(window) = self.windows.get_mut(&window_id) {
1621 window.focused = focused;
1622 if !focused {
1623 window.android_back_down_seen = false;
1624 release_host_cursor(window);
1625 }
1626 }
1627 self.process_event(
1628 event_loop,
1629 window_id,
1630 Event::Window(WindowEvent::Focused(focused)),
1631 )
1632 }
1633 WinitWindowEvent::Occluded(occluded) => {
1634 if let Some(window) = self.windows.get_mut(&window_id) {
1635 window.occluded = occluded;
1636 }
1637 self.process_event(
1638 event_loop,
1639 window_id,
1640 Event::Window(WindowEvent::Occluded(occluded)),
1641 )
1642 }
1643 WinitWindowEvent::RedrawRequested => self.process_event(
1644 event_loop,
1645 window_id,
1646 Event::Window(WindowEvent::RedrawRequested),
1647 ),
1648 WinitWindowEvent::ModifiersChanged(modifiers) => {
1649 if let Some(window) = self.windows.get_mut(&window_id) {
1650 window.pointer.modifiers = modifiers_state_to_modifiers(modifiers.state());
1651 }
1652 Ok(())
1653 }
1654 WinitWindowEvent::CursorMoved { position, .. } => {
1655 let event = if let Some(window) = self.windows.get_mut(&window_id) {
1656 let next_position =
1657 physical_position_to_logical_point(position, window.scale_factor);
1658 let delta = Vector::new(
1659 next_position.x - window.pointer.position.x,
1660 next_position.y - window.pointer.position.y,
1661 );
1662 window.pointer.position = next_position;
1663 Event::Pointer(PointerEvent {
1664 pointer_id: 1,
1665 kind: PointerEventKind::Move,
1666 position: next_position,
1667 delta,
1668 scroll_delta: None,
1669 button: None,
1670 buttons: window.pointer.buttons,
1671 modifiers: window.pointer.modifiers,
1672 pointer_kind: PointerKind::Mouse,
1673 is_primary: true,
1674 })
1675 } else {
1676 return Ok(());
1677 };
1678
1679 self.process_event(event_loop, window_id, event)
1680 }
1681 WinitWindowEvent::CursorEntered { .. } => {
1682 let event = if let Some(window) = self.windows.get(&window_id) {
1683 Event::Pointer(PointerEvent {
1684 pointer_id: 1,
1685 kind: PointerEventKind::Enter,
1686 position: window.pointer.position,
1687 delta: Vector::ZERO,
1688 scroll_delta: None,
1689 button: None,
1690 buttons: window.pointer.buttons,
1691 modifiers: window.pointer.modifiers,
1692 pointer_kind: PointerKind::Mouse,
1693 is_primary: true,
1694 })
1695 } else {
1696 return Ok(());
1697 };
1698
1699 self.process_event(event_loop, window_id, event)
1700 }
1701 WinitWindowEvent::CursorLeft { .. } => {
1702 let event = if let Some(window) = self.windows.get(&window_id) {
1703 Event::Pointer(PointerEvent {
1704 pointer_id: 1,
1705 kind: PointerEventKind::Leave,
1706 position: window.pointer.position,
1707 delta: Vector::ZERO,
1708 scroll_delta: None,
1709 button: None,
1710 buttons: window.pointer.buttons,
1711 modifiers: window.pointer.modifiers,
1712 pointer_kind: PointerKind::Mouse,
1713 is_primary: true,
1714 })
1715 } else {
1716 return Ok(());
1717 };
1718
1719 self.process_event(event_loop, window_id, event)
1720 }
1721 WinitWindowEvent::MouseInput { state, button, .. } => {
1722 let event = if let Some(window) = self.windows.get_mut(&window_id) {
1723 let Some(pointer_button) = map_mouse_button(button) else {
1724 return Ok(());
1725 };
1726
1727 match state {
1728 ElementState::Pressed => window.pointer.buttons.insert(pointer_button),
1729 ElementState::Released => {
1730 window.pointer.buttons =
1731 remove_pointer_button(window.pointer.buttons, pointer_button);
1732 }
1733 }
1734
1735 Event::Pointer(PointerEvent {
1736 pointer_id: 1,
1737 kind: match state {
1738 ElementState::Pressed => PointerEventKind::Down,
1739 ElementState::Released => PointerEventKind::Up,
1740 },
1741 position: window.pointer.position,
1742 delta: Vector::ZERO,
1743 scroll_delta: None,
1744 button: Some(pointer_button),
1745 buttons: window.pointer.buttons,
1746 modifiers: window.pointer.modifiers,
1747 pointer_kind: PointerKind::Mouse,
1748 is_primary: true,
1749 })
1750 } else {
1751 return Ok(());
1752 };
1753
1754 self.process_event(event_loop, window_id, event)
1755 }
1756 WinitWindowEvent::MouseWheel { delta, .. } => {
1757 let event = if let Some(window) = self.windows.get(&window_id) {
1758 Event::Pointer(PointerEvent {
1759 pointer_id: 1,
1760 kind: PointerEventKind::Scroll,
1761 position: window.pointer.position,
1762 delta: Vector::ZERO,
1763 scroll_delta: Some(match delta {
1764 MouseScrollDelta::LineDelta(x, y) => {
1765 ScrollDelta::Lines(Vector::new(x, y))
1766 }
1767 MouseScrollDelta::PixelDelta(position) => ScrollDelta::Pixels(
1768 physical_position_to_logical_vector(position, window.scale_factor),
1769 ),
1770 }),
1771 button: None,
1772 buttons: window.pointer.buttons,
1773 modifiers: window.pointer.modifiers,
1774 pointer_kind: PointerKind::Mouse,
1775 is_primary: true,
1776 })
1777 } else {
1778 return Ok(());
1779 };
1780
1781 self.process_event(event_loop, window_id, event)
1782 }
1783 WinitWindowEvent::Touch(touch) => {
1784 let event = if let Some(window) = self.windows.get_mut(&window_id) {
1785 let position =
1786 physical_position_to_logical_point(touch.location, window.scale_factor);
1787 let previous = window
1788 .touch_points
1789 .get(&touch.id)
1790 .copied()
1791 .unwrap_or(position);
1792 let kind = match touch.phase {
1793 TouchPhase::Started => PointerEventKind::Down,
1794 TouchPhase::Moved => PointerEventKind::Move,
1795 TouchPhase::Ended => PointerEventKind::Up,
1796 TouchPhase::Cancelled => PointerEventKind::Cancel,
1797 };
1798 let was_primary = window
1799 .touch_points
1800 .keys()
1801 .min()
1802 .copied()
1803 .map(|id| id == touch.id)
1804 .unwrap_or(true);
1805 match touch.phase {
1806 TouchPhase::Started | TouchPhase::Moved => {
1807 window.touch_points.insert(touch.id, position);
1808 }
1809 TouchPhase::Ended | TouchPhase::Cancelled => {
1810 window.touch_points.remove(&touch.id);
1811 }
1812 }
1813 let buttons = match touch.phase {
1814 TouchPhase::Started | TouchPhase::Moved => PointerButtons::new(1),
1815 TouchPhase::Ended | TouchPhase::Cancelled => PointerButtons::NONE,
1816 };
1817 Event::Pointer(PointerEvent {
1818 pointer_id: touch.id,
1819 kind,
1820 position,
1821 delta: Vector::new(position.x - previous.x, position.y - previous.y),
1822 scroll_delta: None,
1823 button: match touch.phase {
1824 TouchPhase::Started | TouchPhase::Ended => Some(PointerButton::Primary),
1825 TouchPhase::Moved | TouchPhase::Cancelled => None,
1826 },
1827 buttons,
1828 modifiers: window.pointer.modifiers,
1829 pointer_kind: PointerKind::Touch,
1830 is_primary: was_primary,
1831 })
1832 } else {
1833 return Ok(());
1834 };
1835
1836 self.process_event(event_loop, window_id, event)
1837 }
1838 WinitWindowEvent::KeyboardInput { event, .. } => {
1839 let (effective_state, is_android_back) = if cfg!(target_os = "android") {
1840 let down_seen = self
1841 .windows
1842 .get_mut(&window_id)
1843 .map(|window| &mut window.android_back_down_seen);
1844 down_seen.map_or((event.state, false), |down_seen| {
1845 normalize_android_back_event(
1846 &event.logical_key,
1847 event.state,
1848 event.repeat,
1849 down_seen,
1850 )
1851 })
1852 } else {
1853 (event.state, false)
1854 };
1855 let modifiers = self
1856 .windows
1857 .get(&window_id)
1858 .map(|window| window.pointer.modifiers)
1859 .unwrap_or(Modifiers::NONE);
1860 let keyboard_event = KeyboardEvent {
1861 key: logical_key_to_string(&event.logical_key),
1862 code: physical_key_to_string(&event.physical_key),
1863 text: event.text.as_ref().map(|text| text.to_string()),
1864 state: match effective_state {
1865 ElementState::Pressed => KeyState::Pressed,
1866 ElementState::Released => KeyState::Released,
1867 },
1868 modifiers,
1869 repeat: event.repeat,
1870 is_composing: false,
1871 };
1872 let handled = self.process_event_with_outcome(
1873 event_loop,
1874 window_id,
1875 Event::Keyboard(keyboard_event),
1876 )?;
1877 if is_android_back && !handled {
1878 self.process_event(
1879 event_loop,
1880 window_id,
1881 Event::Window(WindowEvent::CloseRequested),
1882 )?;
1883 }
1884 Ok(())
1885 }
1886 WinitWindowEvent::Ime(ime) => {
1887 if let Some(ime_event) = map_ime_event(ime) {
1888 self.process_event(event_loop, window_id, Event::Ime(ime_event))
1889 } else {
1890 Ok(())
1891 }
1892 }
1893 _ => Ok(()),
1894 }
1895 }
1896
1897 fn handle_device_event(
1898 &mut self,
1899 event_loop: &ActiveEventLoop,
1900 event: DeviceEvent,
1901 ) -> Result<()> {
1902 let DeviceEvent::MouseMotion { delta } = event else {
1903 return Ok(());
1904 };
1905 let Some((window_id, modifiers)) = self.windows.iter().find_map(|(&window_id, window)| {
1906 (window.focused && window.applied_cursor_grab != CursorGrabMode::None)
1907 .then_some((window_id, window.pointer.modifiers))
1908 }) else {
1909 return Ok(());
1910 };
1911 let delta = raw_mouse_motion_to_vector(delta);
1912 self.process_event(
1913 event_loop,
1914 window_id,
1915 Event::RawMouseMotion(RawMouseMotionEvent { delta, modifiers }),
1916 )
1917 }
1918
1919 #[cfg(target_os = "windows")]
1920 fn handle_accesskit_event(
1921 &mut self,
1922 event_loop: &ActiveEventLoop,
1923 event: AccessKitEvent,
1924 ) -> Result<()> {
1925 let Some(window_id) = self.host_to_runtime.get(&event.window_id).copied() else {
1926 return Ok(());
1927 };
1928
1929 match event.window_event {
1930 AccessKitWindowEvent::InitialTreeRequested => {
1931 let Some(window) = self.windows.get_mut(&window_id) else {
1932 return Ok(());
1933 };
1934 let snapshot = build_accesskit_snapshot(
1935 window_id,
1936 window.scale_factor,
1937 &window.title,
1938 window
1939 .accessibility
1940 .snapshot()
1941 .map(|snapshot| snapshot.nodes.as_slice())
1942 .unwrap_or(&[]),
1943 );
1944 let update = snapshot.full_update();
1945 window.accesskit_snapshot = snapshot;
1946 let WindowState {
1947 accesskit_adapter, ..
1948 } = window;
1949 accesskit_adapter.update_if_active(|| update);
1950 Ok(())
1951 }
1952 AccessKitWindowEvent::ActionRequested(request) => {
1953 let mapped = self
1954 .windows
1955 .get(&window_id)
1956 .and_then(|window| window.accesskit_snapshot.map_action(&request));
1957 let Some((target, action)) = mapped else {
1958 return Ok(());
1959 };
1960
1961 self.update_clock();
1964 self.runtime.tick(self.frame_clock);
1965 let _handled = self
1966 .runtime
1967 .handle_semantics_action(window_id, target, action)?;
1968 self.drive_runtime(event_loop)
1969 }
1970 AccessKitWindowEvent::AccessibilityDeactivated => Ok(()),
1971 }
1972 }
1973
1974 fn handle_error(&mut self, event_loop: &ActiveEventLoop, error: Error) {
1975 self.last_error = Some(error);
1976 event_loop.exit();
1977 }
1978
1979 fn drive_automation(&mut self, event_loop: &ActiveEventLoop) -> Result<()> {
1980 let now = Instant::now();
1981 let mut state = match self.automation.take() {
1982 Some(state) => state,
1983 None => return Ok(()),
1984 };
1985
1986 if state.shutdown_requested {
1987 self.automation = Some(state);
1988 return Ok(());
1989 }
1990
1991 if state.started_at.is_none() && now >= state.armed_at + state.config.startup_timeout {
1992 println!(
1993 "[desktop automation:{}] timed out waiting for target {:?} named {:?}",
1994 state.config.label, state.config.target_role, state.config.target_name
1995 );
1996 state.shutdown_requested = true;
1997 self.automation = Some(state);
1998 return Ok(());
1999 }
2000
2001 if let Some((window_id, target_point)) = self.find_automation_target(&state) {
2002 if state.started_at.is_none() {
2003 state.started_at = Some(now);
2004 state.last_report_at = Some(now);
2005 state.last_report_frame_index = window_performance_snapshot(window_id)
2006 .map(|snapshot| snapshot.frame_index)
2007 .unwrap_or(0);
2008 state.target_window_id = Some(window_id);
2009 println!(
2010 "[desktop automation:{}] started on window {}",
2011 state.config.label,
2012 window_id.get()
2013 );
2014 self.process_event(
2015 event_loop,
2016 window_id,
2017 Event::Window(WindowEvent::Focused(true)),
2018 )?;
2019 }
2020
2021 if !state.pointer_primed {
2022 self.inject_pointer_move(event_loop, window_id, target_point, true)?;
2023 state.pointer_primed = true;
2024 }
2025
2026 self.report_automation_progress(&mut state, false);
2027
2028 let started_at = state.started_at.expect("automation should have started");
2029 if now >= started_at + state.config.duration {
2030 self.report_automation_progress(&mut state, true);
2031 println!("[desktop automation:{}] completed", state.config.label);
2032 state.shutdown_requested = true;
2033 self.automation = Some(state);
2034 return Ok(());
2035 }
2036
2037 if now >= state.next_step_at {
2038 self.inject_automation_action(
2039 event_loop,
2040 window_id,
2041 target_point,
2042 &state.config.action,
2043 )?;
2044 state.next_step_at = now + state.config.step_interval;
2045 }
2046 }
2047
2048 self.automation = Some(state);
2049 Ok(())
2050 }
2051
2052 fn find_automation_target(&self, state: &DesktopAutomationState) -> Option<(WindowId, Point)> {
2053 self.windows.iter().find_map(|(window_id, window)| {
2054 let snapshot = window.accessibility.snapshot()?;
2055 let node = snapshot.nodes.iter().find(|node| {
2056 node.role == state.config.target_role
2057 && node.name.as_deref() == Some(state.config.target_name.as_str())
2058 })?;
2059 let point = if node.role == SemanticsRole::ScrollView {
2060 Point::new(
2061 node.bounds.x() + node.bounds.width().min(48.0),
2062 node.bounds.y() + node.bounds.height() * 0.5,
2063 )
2064 } else {
2065 Point::new(
2066 node.bounds.x() + node.bounds.width() * 0.5,
2067 node.bounds.y() + node.bounds.height() * 0.5,
2068 )
2069 };
2070 Some((*window_id, point))
2071 })
2072 }
2073
2074 fn report_automation_progress(&self, state: &mut DesktopAutomationState, force: bool) {
2075 let Some(window_id) = state.target_window_id else {
2076 return;
2077 };
2078 let now = Instant::now();
2079 let Some(last_report_at) = state.last_report_at else {
2080 state.last_report_at = Some(now);
2081 return;
2082 };
2083 if !force && now < last_report_at + state.config.report_interval {
2084 return;
2085 }
2086 let Some(snapshot) = window_performance_snapshot(window_id) else {
2087 state.last_report_at = Some(now);
2088 return;
2089 };
2090 let elapsed = (now - last_report_at).as_secs_f64().max(f64::EPSILON);
2091 let frame_delta = snapshot
2092 .frame_index
2093 .saturating_sub(state.last_report_frame_index);
2094 let observed_fps = frame_delta as f64 / elapsed;
2095 Self::print_automation_snapshot(&state.config.label, observed_fps, &snapshot);
2096 state.last_report_at = Some(now);
2097 state.last_report_frame_index = snapshot.frame_index;
2098 }
2099
2100 fn print_automation_snapshot(
2101 label: &str,
2102 observed_fps: f64,
2103 snapshot: &WindowPerformanceSnapshot,
2104 ) {
2105 let slowest_phase = snapshot
2106 .slowest_phase()
2107 .map(|sample| format!("{}:{:.3}ms", sample.phase.label(), sample.duration_ms))
2108 .unwrap_or_else(|| "n/a".to_string());
2109 let phase_breakdown = if snapshot.phase_timings.is_empty() {
2110 "n/a".to_string()
2111 } else {
2112 snapshot
2113 .phase_timings
2114 .iter()
2115 .map(|sample| format!("{}={:.3}", sample.phase.label(), sample.duration_ms))
2116 .collect::<Vec<_>>()
2117 .join(",")
2118 };
2119 let renderer_breakdown = format!(
2120 "comp={:.3},traverse={:.3},batch={:.3},upload={:.3},encode={:.3},submit={:.3},res={:.3},bind={:.3},atlas_miss={}({:.3}ms)",
2121 snapshot.renderer_submission.composition_time_us as f64 / 1000.0,
2122 snapshot
2123 .renderer_submission
2124 .retained_scene_traversal_time_us as f64
2125 / 1000.0,
2126 snapshot.renderer_submission.batch_prepare_time_us as f64 / 1000.0,
2127 snapshot.renderer_submission.gpu_upload_time_us as f64 / 1000.0,
2128 snapshot.renderer_submission.pass_encode_time_us as f64 / 1000.0,
2129 snapshot.renderer_submission.queue_submit_time_us as f64 / 1000.0,
2130 snapshot.renderer_submission.resource_collection_time_us as f64 / 1000.0,
2131 snapshot.renderer_submission.bind_group_prepare_time_us as f64 / 1000.0,
2132 snapshot.renderer_submission.text_atlas_miss_count,
2133 snapshot.renderer_submission.text_atlas_miss_time_us as f64 / 1000.0,
2134 );
2135 let hotspot = snapshot
2136 .retained_packet_hotspot
2137 .as_ref()
2138 .map(|hotspot| {
2139 format!(
2140 "widget={:?},total={:.3}ms,cmds={},text={},paths={},rects={}",
2141 hotspot.owner_widget_id,
2142 hotspot.total_time_us as f64 / 1000.0,
2143 hotspot.command_count,
2144 hotspot.text_command_count,
2145 hotspot.path_command_count,
2146 hotspot.rect_command_count,
2147 )
2148 })
2149 .unwrap_or_else(|| "n/a".to_string());
2150 println!(
2151 "[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=[{}]",
2152 snapshot.frame_index,
2153 snapshot.total_time_ms,
2154 slowest_phase,
2155 snapshot.scene.dirty_coverage,
2156 snapshot.scene.command_count,
2157 snapshot.renderer_submission.surface_acquire_time_us as f64 / 1000.0,
2158 snapshot.renderer_submission.surface_present_time_us as f64 / 1000.0,
2159 snapshot.renderer_submission.retained_packet_build_time_us as f64 / 1000.0,
2160 snapshot.renderer_submission.retained_state_update_time_us as f64 / 1000.0,
2161 snapshot.renderer_submission.visible_layer_count,
2162 snapshot.renderer_submission.draw_count,
2163 phase_breakdown,
2164 renderer_breakdown,
2165 hotspot,
2166 );
2167 }
2168
2169 #[cfg(target_arch = "wasm32")]
2170 fn process_web_interop_commands(&mut self, event_loop: &ActiveEventLoop) -> Result<()> {
2171 for command in crate::web_interop::drain_commands() {
2172 match command {
2173 crate::web_interop::WebInteropCommand::Click { target } => {
2174 if let Some((window_id, node)) = self.find_semantics_node(&target) {
2175 if let Some(action) = web_click_semantics_action(&node) {
2176 let _ = self
2177 .runtime
2178 .handle_semantics_action(window_id, node.id, action)?;
2179 } else {
2180 self.inject_pointer_click(event_loop, window_id, center(node.bounds))?;
2181 }
2182 }
2183 }
2184 crate::web_interop::WebInteropCommand::Scroll {
2185 target,
2186 delta_x,
2187 delta_y,
2188 } => {
2189 if let Some((window_id, point)) = self.find_semantics_node_point(&target) {
2190 self.inject_pointer_scroll(
2191 event_loop,
2192 window_id,
2193 point,
2194 Vector::new(delta_x, delta_y),
2195 )?;
2196 }
2197 }
2198 crate::web_interop::WebInteropCommand::Key { target, key } => {
2199 if let Some((window_id, point)) = self.find_semantics_node_point(&target) {
2200 self.inject_pointer_click(event_loop, window_id, point)?;
2201 self.inject_key(event_loop, window_id, key)?;
2202 }
2203 }
2204 crate::web_interop::WebInteropCommand::Text { target, text } => {
2205 if let Some((window_id, point)) = self.find_semantics_node_point(&target) {
2206 self.inject_pointer_click(event_loop, window_id, point)?;
2207 self.inject_text(event_loop, window_id, text)?;
2208 }
2209 }
2210 }
2211 }
2212
2213 Ok(())
2214 }
2215
2216 #[cfg(target_arch = "wasm32")]
2217 fn find_semantics_node(
2218 &self,
2219 target: &crate::web_interop::WebInteropTarget,
2220 ) -> Option<(WindowId, sui_core::SemanticsNode)> {
2221 self.windows.iter().find_map(|(window_id, window)| {
2222 let snapshot = window.accessibility.snapshot()?;
2223 let node = target
2224 .widget_id
2225 .and_then(|widget_id| snapshot.nodes.iter().find(|node| node.id == widget_id))
2226 .or_else(|| {
2227 snapshot.nodes.iter().find(|node| {
2228 target.role.as_deref().is_none_or(|role| {
2229 format!("{:?}", node.role).eq_ignore_ascii_case(role)
2230 }) && target
2231 .name
2232 .as_deref()
2233 .is_none_or(|name| node.name.as_deref() == Some(name))
2234 })
2235 })?;
2236 Some((*window_id, node.clone()))
2237 })
2238 }
2239
2240 #[cfg(target_arch = "wasm32")]
2241 fn find_semantics_node_point(
2242 &self,
2243 target: &crate::web_interop::WebInteropTarget,
2244 ) -> Option<(WindowId, Point)> {
2245 self.find_semantics_node(target)
2246 .map(|(window_id, node)| (window_id, center(node.bounds)))
2247 }
2248
2249 #[cfg(target_arch = "wasm32")]
2250 fn inject_pointer_click(
2251 &mut self,
2252 event_loop: &ActiveEventLoop,
2253 window_id: WindowId,
2254 point: Point,
2255 ) -> Result<()> {
2256 self.inject_pointer_move(event_loop, window_id, point, false)?;
2257 let modifiers = self
2258 .windows
2259 .get(&window_id)
2260 .map(|window| window.pointer.modifiers)
2261 .ok_or_else(|| Error::new(format!("missing window {}", window_id.get())))?;
2262
2263 let down_buttons = {
2264 let window = self
2265 .windows
2266 .get_mut(&window_id)
2267 .ok_or_else(|| Error::new(format!("missing window {}", window_id.get())))?;
2268 window.pointer.buttons.insert(PointerButton::Primary);
2269 window.pointer.buttons
2270 };
2271 self.process_event(
2272 event_loop,
2273 window_id,
2274 Event::Pointer(PointerEvent {
2275 pointer_id: 1,
2276 kind: PointerEventKind::Down,
2277 position: point,
2278 delta: Vector::ZERO,
2279 scroll_delta: None,
2280 button: Some(PointerButton::Primary),
2281 buttons: down_buttons,
2282 modifiers,
2283 pointer_kind: PointerKind::Mouse,
2284 is_primary: true,
2285 }),
2286 )?;
2287
2288 let up_buttons = {
2289 let window = self
2290 .windows
2291 .get_mut(&window_id)
2292 .ok_or_else(|| Error::new(format!("missing window {}", window_id.get())))?;
2293 window.pointer.buttons =
2294 remove_pointer_button(window.pointer.buttons, PointerButton::Primary);
2295 window.pointer.buttons
2296 };
2297 self.process_event(
2298 event_loop,
2299 window_id,
2300 Event::Pointer(PointerEvent {
2301 pointer_id: 1,
2302 kind: PointerEventKind::Up,
2303 position: point,
2304 delta: Vector::ZERO,
2305 scroll_delta: None,
2306 button: Some(PointerButton::Primary),
2307 buttons: up_buttons,
2308 modifiers,
2309 pointer_kind: PointerKind::Mouse,
2310 is_primary: true,
2311 }),
2312 )
2313 }
2314
2315 #[cfg(target_arch = "wasm32")]
2316 fn inject_pointer_scroll(
2317 &mut self,
2318 event_loop: &ActiveEventLoop,
2319 window_id: WindowId,
2320 point: Point,
2321 delta: Vector,
2322 ) -> Result<()> {
2323 self.inject_pointer_move(event_loop, window_id, point, false)?;
2324 let (buttons, modifiers) = self
2325 .windows
2326 .get(&window_id)
2327 .map(|window| (window.pointer.buttons, window.pointer.modifiers))
2328 .ok_or_else(|| Error::new(format!("missing window {}", window_id.get())))?;
2329 self.process_event(
2330 event_loop,
2331 window_id,
2332 Event::Pointer(PointerEvent {
2333 pointer_id: 1,
2334 kind: PointerEventKind::Scroll,
2335 position: point,
2336 delta: Vector::ZERO,
2337 scroll_delta: Some(ScrollDelta::Pixels(delta)),
2338 button: None,
2339 buttons,
2340 modifiers,
2341 pointer_kind: PointerKind::Mouse,
2342 is_primary: true,
2343 }),
2344 )
2345 }
2346
2347 #[cfg(target_arch = "wasm32")]
2348 fn inject_key(
2349 &mut self,
2350 event_loop: &ActiveEventLoop,
2351 window_id: WindowId,
2352 key: String,
2353 ) -> Result<()> {
2354 self.process_event(
2355 event_loop,
2356 window_id,
2357 Event::Keyboard(KeyboardEvent::new(key.clone(), KeyState::Pressed)),
2358 )?;
2359 self.process_event(
2360 event_loop,
2361 window_id,
2362 Event::Keyboard(KeyboardEvent::new(key, KeyState::Released)),
2363 )
2364 }
2365
2366 #[cfg(target_arch = "wasm32")]
2367 fn inject_text(
2368 &mut self,
2369 event_loop: &ActiveEventLoop,
2370 window_id: WindowId,
2371 text: String,
2372 ) -> Result<()> {
2373 self.process_event(
2374 event_loop,
2375 window_id,
2376 Event::Ime(ImeEvent::CompositionStart),
2377 )?;
2378 self.process_event(
2379 event_loop,
2380 window_id,
2381 Event::Ime(ImeEvent::CompositionUpdate {
2382 text: text.clone(),
2383 cursor_range: None,
2384 }),
2385 )?;
2386 self.process_event(
2387 event_loop,
2388 window_id,
2389 Event::Ime(ImeEvent::CompositionCommit { text }),
2390 )?;
2391 self.process_event(event_loop, window_id, Event::Ime(ImeEvent::CompositionEnd))
2392 }
2393
2394 fn inject_automation_action(
2395 &mut self,
2396 event_loop: &ActiveEventLoop,
2397 window_id: WindowId,
2398 target_point: Point,
2399 action: &DesktopAutomationAction,
2400 ) -> Result<()> {
2401 match action {
2402 DesktopAutomationAction::ScrollPixels { delta } => {
2403 self.inject_pointer_move(event_loop, window_id, target_point, false)?;
2404 let (buttons, modifiers) = self
2405 .windows
2406 .get(&window_id)
2407 .map(|window| (window.pointer.buttons, window.pointer.modifiers))
2408 .ok_or_else(|| Error::new(format!("missing window {}", window_id.get())))?;
2409 self.process_event(
2410 event_loop,
2411 window_id,
2412 Event::Pointer(PointerEvent {
2413 pointer_id: 1,
2414 kind: PointerEventKind::Scroll,
2415 position: target_point,
2416 delta: Vector::ZERO,
2417 scroll_delta: Some(ScrollDelta::Pixels(*delta)),
2418 button: None,
2419 buttons,
2420 modifiers,
2421 pointer_kind: PointerKind::Mouse,
2422 is_primary: true,
2423 }),
2424 )
2425 }
2426 }
2427 }
2428
2429 fn inject_pointer_move(
2430 &mut self,
2431 event_loop: &ActiveEventLoop,
2432 window_id: WindowId,
2433 position: Point,
2434 emit_enter: bool,
2435 ) -> Result<()> {
2436 let (previous, buttons, modifiers) = {
2437 let window = self
2438 .windows
2439 .get(&window_id)
2440 .ok_or_else(|| Error::new(format!("missing window {}", window_id.get())))?;
2441 (
2442 window.pointer.position,
2443 window.pointer.buttons,
2444 window.pointer.modifiers,
2445 )
2446 };
2447
2448 if emit_enter {
2449 self.process_event(
2450 event_loop,
2451 window_id,
2452 Event::Pointer(PointerEvent {
2453 pointer_id: 1,
2454 kind: PointerEventKind::Enter,
2455 position,
2456 delta: Vector::ZERO,
2457 scroll_delta: None,
2458 button: None,
2459 buttons,
2460 modifiers,
2461 pointer_kind: PointerKind::Mouse,
2462 is_primary: true,
2463 }),
2464 )?;
2465 }
2466
2467 if let Some(window) = self.windows.get_mut(&window_id) {
2468 window.pointer.position = position;
2469 }
2470
2471 self.process_event(
2472 event_loop,
2473 window_id,
2474 Event::Pointer(PointerEvent {
2475 pointer_id: 1,
2476 kind: PointerEventKind::Move,
2477 position,
2478 delta: Vector::new(position.x - previous.x, position.y - previous.y),
2479 scroll_delta: None,
2480 button: None,
2481 buttons,
2482 modifiers,
2483 pointer_kind: PointerKind::Mouse,
2484 is_primary: true,
2485 }),
2486 )
2487 }
2488}
2489
2490#[derive(Debug, Clone, Copy)]
2492pub struct WakeSignal;
2493
2494#[derive(Clone)]
2498pub struct Waker {
2499 proxy: EventLoopProxy<DesktopUserEvent>,
2500 pending: Arc<AtomicBool>,
2501 kind: WakeKind,
2502}
2503
2504#[derive(Debug, Clone, Copy)]
2505enum WakeKind {
2506 External,
2507 Reactive,
2508}
2509
2510impl Waker {
2511 fn new(
2512 proxy: EventLoopProxy<DesktopUserEvent>,
2513 pending: Arc<AtomicBool>,
2514 kind: WakeKind,
2515 ) -> Self {
2516 Self {
2517 proxy,
2518 pending,
2519 kind,
2520 }
2521 }
2522
2523 pub fn wake(&self) {
2524 if self
2525 .pending
2526 .compare_exchange(false, true, Ordering::AcqRel, Ordering::Acquire)
2527 .is_err()
2528 {
2529 return;
2530 }
2531 let event = match self.kind {
2532 WakeKind::External => DesktopUserEvent::ExternalWake(WakeSignal),
2533 WakeKind::Reactive => DesktopUserEvent::ReactiveWake(WakeSignal),
2534 };
2535 if self.proxy.send_event(event).is_err() {
2536 self.pending.store(false, Ordering::Release);
2537 }
2538 }
2539}
2540
2541impl ApplicationHandler<DesktopUserEvent> for DesktopApp {
2542 fn resumed(&mut self, event_loop: &ActiveEventLoop) {
2543 crate::motion_preference::sync_system_motion_preference();
2544 if self.host_lifecycle.resume()
2545 && let Err(error) = self.restore_window_surfaces(event_loop)
2546 {
2547 self.handle_error(event_loop, error);
2548 return;
2549 }
2550 if let Err(error) = self.drive_runtime(event_loop) {
2551 self.handle_error(event_loop, error);
2552 }
2553 }
2554
2555 fn suspended(&mut self, event_loop: &ActiveEventLoop) {
2556 if let Err(error) = self.suspend_window_surfaces() {
2557 self.handle_error(event_loop, error);
2558 return;
2559 }
2560 event_loop.set_control_flow(ControlFlow::Wait);
2561 }
2562
2563 fn user_event(&mut self, event_loop: &ActiveEventLoop, event: DesktopUserEvent) {
2564 match event {
2565 DesktopUserEvent::ExternalWake(_signal) => {
2566 self.external_wake_pending.store(false, Ordering::Release);
2567 self.runtime.process_commands();
2570 if let Err(error) = self.drive_runtime(event_loop) {
2571 self.handle_error(event_loop, error);
2572 }
2573 }
2574 DesktopUserEvent::ReactiveWake(_signal) => {
2575 self.reactive_wake_pending.store(false, Ordering::Release);
2576 self.runtime.process_reactive_updates();
2577 if let Err(error) = self.drive_runtime(event_loop) {
2578 self.handle_error(event_loop, error);
2579 }
2580 }
2581 #[cfg(target_os = "windows")]
2582 DesktopUserEvent::AccessKit(event) => {
2583 if let Err(error) = self.handle_accesskit_event(event_loop, event) {
2584 self.handle_error(event_loop, error);
2585 }
2586 }
2587 }
2588 }
2589
2590 fn window_event(
2591 &mut self,
2592 event_loop: &ActiveEventLoop,
2593 window_id: HostWindowId,
2594 event: WinitWindowEvent,
2595 ) {
2596 if !self.host_lifecycle.is_resumed() {
2597 return;
2598 }
2599 if let Err(error) = self.handle_window_event(event_loop, window_id, event) {
2600 self.handle_error(event_loop, error);
2601 }
2602 }
2603
2604 fn device_event(
2605 &mut self,
2606 event_loop: &ActiveEventLoop,
2607 _device_id: DeviceId,
2608 event: DeviceEvent,
2609 ) {
2610 if !self.host_lifecycle.is_resumed() {
2611 return;
2612 }
2613 if let Err(error) = self.handle_device_event(event_loop, event) {
2614 self.handle_error(event_loop, error);
2615 }
2616 }
2617
2618 fn about_to_wait(&mut self, event_loop: &ActiveEventLoop) {
2619 if let Err(error) = self.drive_runtime(event_loop) {
2620 self.handle_error(event_loop, error);
2621 }
2622 }
2623}
2624
2625fn monitor_refresh_interval(window: &Window) -> Option<f64> {
2628 window
2629 .current_monitor()
2630 .and_then(|monitor| monitor.refresh_rate_millihertz())
2631 .filter(|millihertz| *millihertz > 0)
2632 .map(|millihertz| 1000.0 / f64::from(millihertz))
2633}
2634
2635#[cfg_attr(target_arch = "wasm32", allow(dead_code))]
2636struct WindowState {
2637 id: WindowId,
2638 title: String,
2639 display_capabilities_dirty: bool,
2640 awaiting_performance_bootstrap: bool,
2641 redraw_requested: bool,
2642 redraw_requested_at_ms: Option<f64>,
2643 frame_index: u64,
2644 pending_event_time_ms: f64,
2645 last_non_redraw_event_at_ms: Option<f64>,
2646 accessibility: AccessibilityBridge,
2647 #[cfg(target_os = "windows")]
2648 accesskit_adapter: AccessKitAdapter,
2649 #[cfg(target_os = "windows")]
2650 accesskit_snapshot: AccessKitSnapshot,
2651 pointer: PointerState,
2652 focused: bool,
2653 occluded: bool,
2654 applied_cursor_grab: CursorGrabMode,
2655 applied_cursor_revision: u64,
2656 touch_points: HashMap<u64, Point>,
2657 android_back_down_seen: bool,
2658 ime_allowed: bool,
2659 scale_factor: f64,
2660 refresh_interval: Option<f64>,
2662 cadence: FrameCadence,
2663 frame_pacing: FramePacing,
2664 window: Arc<Window>,
2665}
2666
2667impl WindowState {
2668 fn snapshot(&self) -> PlatformWindow {
2669 PlatformWindow {
2670 id: self.id,
2671 title: self.title.clone(),
2672 accessibility: self.accessibility.snapshot().cloned(),
2673 }
2674 }
2675}
2676
2677#[derive(Debug, Clone, Copy)]
2678struct PointerState {
2679 position: Point,
2680 buttons: PointerButtons,
2681 modifiers: Modifiers,
2682}
2683
2684impl Default for PointerState {
2685 fn default() -> Self {
2686 Self {
2687 position: Point::ZERO,
2688 buttons: PointerButtons::NONE,
2689 modifiers: Modifiers::NONE,
2690 }
2691 }
2692}
2693
2694fn apply_host_cursor_grab(window: &Window, requested: CursorGrabMode) -> CursorGrabMode {
2695 apply_cursor_grab_with(requested, |mode| window.set_cursor_grab(mode))
2696}
2697
2698fn apply_cursor_grab_with<E>(
2699 requested: CursorGrabMode,
2700 mut set_mode: impl FnMut(WinitCursorGrabMode) -> std::result::Result<(), E>,
2701) -> CursorGrabMode {
2702 match requested {
2703 CursorGrabMode::None => {
2704 let _ = set_mode(WinitCursorGrabMode::None);
2705 CursorGrabMode::None
2706 }
2707 CursorGrabMode::Confined => {
2708 if set_mode(WinitCursorGrabMode::Confined).is_ok() {
2709 CursorGrabMode::Confined
2710 } else {
2711 let _ = set_mode(WinitCursorGrabMode::None);
2712 CursorGrabMode::None
2713 }
2714 }
2715 CursorGrabMode::Locked => {
2716 if set_mode(WinitCursorGrabMode::Locked).is_ok() {
2717 CursorGrabMode::Locked
2718 } else if set_mode(WinitCursorGrabMode::Confined).is_ok() {
2719 CursorGrabMode::Confined
2720 } else {
2721 let _ = set_mode(WinitCursorGrabMode::None);
2722 CursorGrabMode::None
2723 }
2724 }
2725 }
2726}
2727
2728fn release_host_cursor(window: &mut WindowState) {
2729 let _ = window.window.set_cursor_grab(WinitCursorGrabMode::None);
2730 window.window.set_cursor_visible(true);
2731 window.applied_cursor_grab = CursorGrabMode::None;
2732}
2733
2734#[cfg(not(target_arch = "wasm32"))]
2735#[allow(
2736 clippy::cast_possible_truncation,
2737 clippy::cast_precision_loss,
2738 clippy::cast_sign_loss
2739)]
2740fn safe_initial_window_placement(
2741 requested_size: Size,
2742 requested_position: Option<Point>,
2743 monitors: &[MonitorHandle],
2744) -> (Size, Option<Point>) {
2745 let mut size = if requested_size.width.is_finite()
2746 && requested_size.height.is_finite()
2747 && requested_size.width > 0.0
2748 && requested_size.height > 0.0
2749 {
2750 requested_size
2751 } else {
2752 DesktopPlatform::DEFAULT_WINDOW_SIZE
2753 };
2754 size.width = size.width.clamp(320.0, 8_192.0);
2755 size.height = size.height.clamp(240.0, 8_192.0);
2756
2757 let requested_position = requested_position.filter(|position| {
2758 position.x.is_finite()
2759 && position.y.is_finite()
2760 && position.x.abs() <= 1_000_000.0
2761 && position.y.abs() <= 1_000_000.0
2762 });
2763 let mut best = None;
2764 for monitor in monitors {
2765 let origin = monitor.position();
2766 let extent = monitor.size();
2767 let scale = monitor.scale_factor().max(1.0);
2768 let physical_width = f64::from(size.width) * scale;
2769 let physical_height = f64::from(size.height) * scale;
2770 let intersection = requested_position.map_or(0.0, |position| {
2771 let left = f64::from(position.x).max(f64::from(origin.x));
2772 let top = f64::from(position.y).max(f64::from(origin.y));
2773 let right = (f64::from(position.x) + physical_width)
2774 .min(f64::from(origin.x) + f64::from(extent.width));
2775 let bottom = (f64::from(position.y) + physical_height)
2776 .min(f64::from(origin.y) + f64::from(extent.height));
2777 (right - left).max(0.0) * (bottom - top).max(0.0)
2778 });
2779 if best
2780 .as_ref()
2781 .is_none_or(|(_, best_intersection): &(&MonitorHandle, f64)| {
2782 intersection > *best_intersection
2783 })
2784 {
2785 best = Some((monitor, intersection));
2786 }
2787 }
2788
2789 let Some((monitor, intersection)) = best else {
2790 return (size, None);
2791 };
2792 let scale = monitor.scale_factor().max(1.0);
2793 let monitor_size = monitor.size();
2794 size.width = size
2795 .width
2796 .min((f64::from(monitor_size.width) / scale).max(320.0) as f32);
2797 size.height = size
2798 .height
2799 .min((f64::from(monitor_size.height) / scale).max(240.0) as f32);
2800
2801 let Some(position) = requested_position else {
2802 return (size, None);
2803 };
2804 let visible_threshold = 96.0 * 48.0;
2805 if intersection < visible_threshold {
2806 return (size, None);
2807 }
2808 let origin = monitor.position();
2809 let physical_width = f64::from(size.width) * scale;
2810 let minimum_x = f64::from(origin.x) - physical_width + 96.0;
2811 let maximum_x = f64::from(origin.x) + f64::from(monitor_size.width) - 96.0;
2812 let minimum_y = f64::from(origin.y);
2813 let maximum_y = f64::from(origin.y) + f64::from(monitor_size.height) - 48.0;
2814 let x = f64::from(position.x).clamp(minimum_x, maximum_x);
2815 let y = f64::from(position.y).clamp(minimum_y, maximum_y);
2816 (size, Some(Point::new(x as f32, y as f32)))
2817}
2818
2819fn physical_size_to_logical_size(size: PhysicalSize<u32>, scale_factor: f64) -> Size {
2820 let logical = size.to_logical::<f32>(scale_factor);
2821 Size::new(logical.width, logical.height)
2822}
2823
2824fn physical_position_to_logical_point(position: PhysicalPosition<f64>, scale_factor: f64) -> Point {
2825 let logical = position.to_logical::<f32>(scale_factor);
2826 Point::new(logical.x, logical.y)
2827}
2828
2829fn physical_position_to_logical_vector(
2830 position: PhysicalPosition<f64>,
2831 scale_factor: f64,
2832) -> Vector {
2833 let logical = position.to_logical::<f32>(scale_factor);
2834 Vector::new(logical.x, logical.y)
2835}
2836
2837fn raw_mouse_motion_to_vector(delta: (f64, f64)) -> Vector {
2838 Vector::new(delta.0 as f32, delta.1 as f32)
2839}
2840
2841fn apply_ime_composition_rect(
2842 window: &Window,
2843 ime_allowed: &mut bool,
2844 rect: Option<sui_core::Rect>,
2845) {
2846 let cursor_area = rect.and_then(|rect| sanitize_ime_cursor_area(rect, window.scale_factor()));
2847 let next_ime_allowed = cursor_area.is_some();
2848 if next_ime_allowed != *ime_allowed {
2849 window.set_ime_allowed(next_ime_allowed);
2850 *ime_allowed = next_ime_allowed;
2851 }
2852
2853 if let Some((position, size)) = cursor_area {
2854 window.set_ime_cursor_area(position, size);
2855 }
2856}
2857
2858fn sanitize_ime_cursor_area(
2859 rect: sui_core::Rect,
2860 scale_factor: f64,
2861) -> Option<(PhysicalPosition<i32>, PhysicalSize<u32>)> {
2862 if !rect.x().is_finite()
2863 || !rect.y().is_finite()
2864 || !rect.width().is_finite()
2865 || !rect.height().is_finite()
2866 {
2867 return None;
2868 }
2869
2870 let scale_factor = if scale_factor.is_finite() && scale_factor > 0.0 {
2871 scale_factor
2872 } else {
2873 1.0
2874 };
2875 let position = LogicalPosition::new(rect.x() as f64, rect.y() as f64);
2876 let size = LogicalSize::new(rect.width().max(1.0) as f64, rect.height().max(1.0) as f64);
2877 let PhysicalPosition { x, y } = position.to_physical::<i32>(scale_factor);
2878 let PhysicalSize { width, height } = size.to_physical::<i32>(scale_factor);
2879 let x = x.min(i32::MAX - 1);
2880 let y = y.min(i32::MAX - 1);
2881 let max_width = ((i32::MAX as i64) - (x as i64)).clamp(1, i32::MAX as i64) as i32;
2882 let max_height = ((i32::MAX as i64) - (y as i64)).clamp(1, i32::MAX as i64) as i32;
2883 let width = width.clamp(1, max_width) as u32;
2884 let height = height.clamp(1, max_height) as u32;
2885
2886 Some((
2887 PhysicalPosition::new(x, y),
2888 PhysicalSize::new(width, height),
2889 ))
2890}
2891
2892fn modifiers_state_to_modifiers(state: ModifiersState) -> Modifiers {
2893 Modifiers {
2894 shift: state.shift_key(),
2895 control: state.control_key(),
2896 alt: state.alt_key(),
2897 meta: state.super_key(),
2898 }
2899}
2900
2901fn map_mouse_button(button: MouseButton) -> Option<PointerButton> {
2902 match button {
2903 MouseButton::Left => Some(PointerButton::Primary),
2904 MouseButton::Right => Some(PointerButton::Secondary),
2905 MouseButton::Middle => Some(PointerButton::Middle),
2906 MouseButton::Back => Some(PointerButton::Back),
2907 MouseButton::Forward => Some(PointerButton::Forward),
2908 MouseButton::Other(value) => Some(PointerButton::Other(value)),
2909 }
2910}
2911
2912fn remove_pointer_button(buttons: PointerButtons, removed: PointerButton) -> PointerButtons {
2913 let mut next = PointerButtons::NONE;
2914
2915 for button in [
2916 PointerButton::Primary,
2917 PointerButton::Secondary,
2918 PointerButton::Middle,
2919 PointerButton::Back,
2920 PointerButton::Forward,
2921 ] {
2922 if button != removed && buttons.contains(button) {
2923 next.insert(button);
2924 }
2925 }
2926
2927 next
2928}
2929
2930#[cfg(any(target_arch = "wasm32", test))]
2931fn web_click_semantics_action(
2932 node: &sui_core::SemanticsNode,
2933) -> Option<sui_core::SemanticsActionRequest> {
2934 use sui_core::{SemanticsAction, SemanticsActionRequest};
2935
2936 if node.actions.contains(&SemanticsAction::Activate) {
2937 Some(SemanticsActionRequest::Activate)
2938 } else if node.state.expanded == Some(false) && node.actions.contains(&SemanticsAction::Expand)
2939 {
2940 Some(SemanticsActionRequest::Expand)
2941 } else if node.state.expanded == Some(true) && node.actions.contains(&SemanticsAction::Collapse)
2942 {
2943 Some(SemanticsActionRequest::Collapse)
2944 } else if node.actions.contains(&SemanticsAction::Copy) {
2945 Some(SemanticsActionRequest::Copy)
2946 } else {
2947 None
2948 }
2949}
2950
2951#[cfg(target_arch = "wasm32")]
2952fn center(bounds: sui_core::Rect) -> Point {
2953 Point::new(
2954 bounds.x() + (bounds.width() * 0.5),
2955 bounds.y() + (bounds.height() * 0.5),
2956 )
2957}
2958
2959fn logical_key_to_string(key: &Key) -> String {
2960 match key {
2961 Key::Character(text) => text.to_string(),
2962 Key::Named(named) => named_key_to_string(*named),
2963 _ => format!("{key:?}"),
2964 }
2965}
2966
2967fn normalize_android_back_event(
2968 key: &Key,
2969 state: ElementState,
2970 repeat: bool,
2971 down_seen: &mut bool,
2972) -> (ElementState, bool) {
2973 if !matches!(key, Key::Named(NamedKey::BrowserBack)) {
2974 return (state, false);
2975 }
2976
2977 match state {
2978 ElementState::Pressed => {
2979 if !repeat {
2980 *down_seen = true;
2981 }
2982 (state, !repeat)
2983 }
2984 ElementState::Released if std::mem::take(down_seen) => (state, false),
2985 ElementState::Released => (ElementState::Pressed, !repeat),
2989 }
2990}
2991
2992fn named_key_to_string(key: NamedKey) -> String {
2993 match key {
2994 NamedKey::Enter => "Enter".to_string(),
2995 NamedKey::Space => " ".to_string(),
2996 NamedKey::Tab => "Tab".to_string(),
2997 NamedKey::Escape => "Escape".to_string(),
2998 NamedKey::ArrowDown => "ArrowDown".to_string(),
2999 NamedKey::ArrowLeft => "ArrowLeft".to_string(),
3000 NamedKey::ArrowRight => "ArrowRight".to_string(),
3001 NamedKey::ArrowUp => "ArrowUp".to_string(),
3002 _ => format!("{key:?}"),
3003 }
3004}
3005
3006fn physical_key_to_string(key: &PhysicalKey) -> String {
3007 match key {
3008 PhysicalKey::Code(code) => format!("{code:?}"),
3009 PhysicalKey::Unidentified(native_key) => format!("{native_key:?}"),
3010 }
3011}
3012
3013fn map_ime_event(event: Ime) -> Option<ImeEvent> {
3014 match event {
3015 Ime::Enabled => Some(ImeEvent::CompositionStart),
3016 Ime::Preedit(text, cursor_range) => Some(ImeEvent::CompositionUpdate {
3017 text,
3018 cursor_range: cursor_range.map(|(start, end)| start..end),
3019 }),
3020 Ime::Commit(text) => Some(ImeEvent::CompositionCommit { text }),
3021 Ime::Disabled => Some(ImeEvent::CompositionEnd),
3022 }
3023}
3024
3025fn map_external_file_window_event(event: &WinitWindowEvent) -> Option<WindowEvent> {
3026 match event {
3027 WinitWindowEvent::HoveredFile(path) => Some(WindowEvent::ExternalFileHovered(path.clone())),
3028 WinitWindowEvent::HoveredFileCancelled => Some(WindowEvent::ExternalFileHoverCancelled),
3029 WinitWindowEvent::DroppedFile(path) => Some(WindowEvent::ExternalFileDropped(path.clone())),
3030 _ => None,
3031 }
3032}
3033
3034#[cfg(not(target_arch = "wasm32"))]
3035fn window_icon_to_winit_icon(icon: &RuntimeWindowIcon) -> Result<WinitIcon> {
3036 match icon {
3037 RuntimeWindowIcon::Svg { data } => svg_window_icon_to_winit_icon(data),
3038 RuntimeWindowIcon::Rgba8 {
3039 width,
3040 height,
3041 data,
3042 } => WinitIcon::from_rgba(data.to_vec(), *width, *height).map_err(map_icon_error),
3043 }
3044}
3045
3046#[cfg(not(target_arch = "wasm32"))]
3047fn svg_window_icon_to_winit_icon(svg: &[u8]) -> Result<WinitIcon> {
3048 let (width, height, rgba) = rasterize_svg_window_icon_rgba8(svg, DEFAULT_WINDOW_ICON_SIZE)?;
3049 WinitIcon::from_rgba(rgba, width, height).map_err(map_icon_error)
3050}
3051
3052#[cfg(not(target_arch = "wasm32"))]
3053fn rasterize_svg_window_icon_rgba8(svg: &[u8], size: u32) -> Result<(u32, u32, Vec<u8>)> {
3054 if size == 0 {
3055 return Err(Error::new("window icon bitmap size must be non-zero"));
3056 }
3057 let options = resvg::usvg::Options::default();
3058 let tree = resvg::usvg::Tree::from_data(svg, &options)
3059 .map_err(|error| Error::new(format!("failed to parse window icon SVG: {error}")))?;
3060 let source_size = tree.size();
3061 let scale = (size as f32 / source_size.width()).min(size as f32 / source_size.height());
3062 let offset_x = (size as f32 - source_size.width() * scale) * 0.5;
3063 let offset_y = (size as f32 - source_size.height() * scale) * 0.5;
3064 let transform =
3065 resvg::tiny_skia::Transform::from_translate(offset_x, offset_y).pre_scale(scale, scale);
3066
3067 let mut pixmap = resvg::tiny_skia::Pixmap::new(size, size)
3068 .ok_or_else(|| Error::new("failed to allocate window icon bitmap"))?;
3069 resvg::render(&tree, transform, &mut pixmap.as_mut());
3070
3071 let mut rgba = Vec::with_capacity((size * size * 4) as usize);
3072 for pixel in pixmap.pixels() {
3073 let color = pixel.demultiply();
3074 rgba.extend_from_slice(&[color.red(), color.green(), color.blue(), color.alpha()]);
3075 }
3076
3077 Ok((size, size, rgba))
3078}
3079
3080#[cfg(not(target_arch = "wasm32"))]
3081fn map_icon_error(error: winit::window::BadIcon) -> Error {
3082 Error::new(format!("failed to create window icon: {error}"))
3083}
3084
3085#[cfg(target_arch = "wasm32")]
3086fn install_web_favicon(icon: Option<&RuntimeWindowIcon>) -> Result<()> {
3087 let Some(document) = web_sys::window().and_then(|window| window.document()) else {
3088 return Ok(());
3089 };
3090 let Some(head) = document.head() else {
3091 return Ok(());
3092 };
3093
3094 remove_web_icon_link(&document, WEB_LEGACY_FAVICON_ID);
3095 let Some(RuntimeWindowIcon::Svg { data }) = icon else {
3096 remove_web_icon_links(&document);
3097 return Ok(());
3098 };
3099
3100 let svg_url = svg_favicon_data_url(data);
3101 install_web_icon_link(
3102 &document,
3103 &head,
3104 WEB_SVG_FAVICON_ID,
3105 "icon",
3106 "image/svg+xml",
3107 "any",
3108 &svg_url,
3109 )?;
3110 install_web_png_icon(
3111 &document,
3112 &head,
3113 data,
3114 WEB_PNG_FAVICON_ID,
3115 "icon",
3116 "64x64",
3117 64,
3118 );
3119 install_web_png_icon(
3120 &document,
3121 &head,
3122 data,
3123 WEB_APPLE_TOUCH_ICON_ID,
3124 "apple-touch-icon",
3125 "180x180",
3126 180,
3127 );
3128 Ok(())
3129}
3130
3131#[cfg(target_arch = "wasm32")]
3132fn install_web_icon_link(
3133 document: &web_sys::Document,
3134 head: &web_sys::HtmlHeadElement,
3135 id: &str,
3136 rel: &str,
3137 mime_type: &str,
3138 sizes: &str,
3139 href: &str,
3140) -> Result<()> {
3141 let link = if let Some(link) = document.get_element_by_id(id) {
3142 link
3143 } else {
3144 let link = document
3145 .create_element("link")
3146 .map_err(|_| Error::new("failed to create web icon link element"))?;
3147 link.set_attribute("id", id)
3148 .map_err(|_| Error::new("failed to configure web icon id"))?;
3149 head.append_child(&link)
3150 .map_err(|_| Error::new("failed to attach web icon link"))?;
3151 link
3152 };
3153
3154 link.set_attribute("rel", rel)
3155 .map_err(|_| Error::new("failed to configure web icon rel"))?;
3156 link.set_attribute("type", mime_type)
3157 .map_err(|_| Error::new("failed to configure web icon type"))?;
3158 if sizes.is_empty() {
3159 link.remove_attribute("sizes")
3160 .map_err(|_| Error::new("failed to clear web icon sizes"))?;
3161 } else {
3162 link.set_attribute("sizes", sizes)
3163 .map_err(|_| Error::new("failed to configure web icon sizes"))?;
3164 }
3165 link.set_attribute("href", href)
3166 .map_err(|_| Error::new("failed to configure web icon href"))
3167}
3168
3169#[cfg(target_arch = "wasm32")]
3170fn remove_web_icon_links(document: &web_sys::Document) {
3171 remove_web_icon_link(document, WEB_SVG_FAVICON_ID);
3172 remove_web_icon_link(document, WEB_PNG_FAVICON_ID);
3173 remove_web_icon_link(document, WEB_APPLE_TOUCH_ICON_ID);
3174}
3175
3176#[cfg(target_arch = "wasm32")]
3177fn remove_web_icon_link(document: &web_sys::Document, id: &str) {
3178 let Some(link) = document.get_element_by_id(id) else {
3179 return;
3180 };
3181 let Some(parent) = link.parent_node() else {
3182 return;
3183 };
3184 let _ = parent.remove_child(&link);
3185}
3186
3187#[cfg(target_arch = "wasm32")]
3188fn svg_favicon_data_url(svg: &[u8]) -> String {
3189 const HEX: &[u8; 16] = b"0123456789ABCDEF";
3190
3191 let mut url = String::from("data:image/svg+xml;charset=utf-8,");
3192 for byte in svg {
3193 match *byte {
3194 b'A'..=b'Z' | b'a'..=b'z' | b'0'..=b'9' | b'-' | b'_' | b'.' | b'~' => {
3195 url.push(*byte as char)
3196 }
3197 byte => {
3198 url.push('%');
3199 url.push(HEX[(byte >> 4) as usize] as char);
3200 url.push(HEX[(byte & 0x0f) as usize] as char);
3201 }
3202 }
3203 }
3204 url
3205}
3206
3207#[cfg(target_arch = "wasm32")]
3208fn install_web_png_icon(
3209 document: &web_sys::Document,
3210 head: &web_sys::HtmlHeadElement,
3211 svg: &[u8],
3212 link_id: &str,
3213 rel: &str,
3214 sizes: &str,
3215 size: u32,
3216) {
3217 use wasm_bindgen::closure::Closure;
3218
3219 let Ok(canvas_element) = document.create_element("canvas") else {
3220 return;
3221 };
3222 let Ok(canvas) = canvas_element.dyn_into::<web_sys::HtmlCanvasElement>() else {
3223 return;
3224 };
3225 canvas.set_width(size);
3226 canvas.set_height(size);
3227
3228 let Ok(Some(context)) = canvas.get_context("2d") else {
3229 return;
3230 };
3231 let Ok(context) = context.dyn_into::<web_sys::CanvasRenderingContext2d>() else {
3232 return;
3233 };
3234 let Ok(image) = web_sys::HtmlImageElement::new() else {
3235 return;
3236 };
3237
3238 let svg_url = svg_favicon_data_url(svg);
3239 let document = document.clone();
3240 let head = head.clone();
3241 let link_id = link_id.to_string();
3242 let rel = rel.to_string();
3243 let sizes = sizes.to_string();
3244 let image_for_load = image.clone();
3245 let onload = Closure::<dyn FnMut()>::new(move || {
3246 let size = size as f64;
3247 context.clear_rect(0.0, 0.0, size, size);
3248 if context
3249 .draw_image_with_html_image_element_and_dw_and_dh(&image_for_load, 0.0, 0.0, size, size)
3250 .is_ok()
3251 && let Ok(png_url) = canvas.to_data_url_with_type("image/png")
3252 {
3253 let _ = install_web_icon_link(
3254 &document,
3255 &head,
3256 &link_id,
3257 &rel,
3258 "image/png",
3259 &sizes,
3260 &png_url,
3261 );
3262 }
3263 });
3264
3265 image.set_onload(Some(onload.as_ref().unchecked_ref()));
3266 image.set_src(&svg_url);
3267 onload.forget();
3268}
3269
3270fn map_event_loop_error(error: EventLoopError) -> Error {
3271 Error::new(format!("winit event loop error: {error}"))
3272}
3273
3274fn map_os_error(error: OsError) -> Error {
3275 Error::new(format!("failed to create desktop window: {error}"))
3276}
3277
3278#[cfg(test)]
3279mod tests {
3280 use std::path::PathBuf;
3281
3282 use super::{
3283 HostLifecycle, apply_cursor_grab_with, map_external_file_window_event,
3284 normalize_android_back_event, physical_position_to_logical_point,
3285 physical_position_to_logical_vector, physical_size_to_logical_size,
3286 rasterize_svg_window_icon_rgba8, raw_mouse_motion_to_vector, sanitize_ime_cursor_area,
3287 web_click_semantics_action, window_icon_to_winit_icon,
3288 };
3289 use sui_core::{
3290 CursorGrabMode, Rect, SemanticsAction, SemanticsActionRequest, SemanticsNode,
3291 SemanticsRole, WindowEvent,
3292 };
3293 use sui_runtime::WindowIcon;
3294 use winit::dpi::{PhysicalPosition, PhysicalSize};
3295 use winit::{
3296 event::{ElementState, WindowEvent as WinitWindowEvent},
3297 keyboard::{Key, NamedKey},
3298 window::CursorGrabMode as WinitCursorGrabMode,
3299 };
3300
3301 #[test]
3302 fn host_lifecycle_waits_for_resume_and_handles_redundant_callbacks() {
3303 let mut lifecycle = HostLifecycle::default();
3304
3305 assert!(!lifecycle.is_resumed());
3306 assert!(!lifecycle.suspend());
3307 assert!(lifecycle.resume());
3308 assert!(lifecycle.is_resumed());
3309 assert!(!lifecycle.resume());
3310 assert!(lifecycle.suspend());
3311 assert!(!lifecycle.is_resumed());
3312 assert!(!lifecycle.suspend());
3313 assert!(lifecycle.resume());
3314 }
3315
3316 #[test]
3317 fn locked_cursor_grab_falls_back_to_confined_then_releases() {
3318 let mut attempts = Vec::new();
3319 let applied = apply_cursor_grab_with(CursorGrabMode::Locked, |mode| {
3320 attempts.push(mode);
3321 match mode {
3322 WinitCursorGrabMode::Locked => Err(()),
3323 WinitCursorGrabMode::Confined => Ok(()),
3324 WinitCursorGrabMode::None => Ok(()),
3325 }
3326 });
3327 assert_eq!(applied, CursorGrabMode::Confined);
3328 assert_eq!(
3329 attempts,
3330 [WinitCursorGrabMode::Locked, WinitCursorGrabMode::Confined]
3331 );
3332
3333 attempts.clear();
3334 let applied = apply_cursor_grab_with(CursorGrabMode::Locked, |mode| {
3335 attempts.push(mode);
3336 (mode == WinitCursorGrabMode::None).then_some(()).ok_or(())
3337 });
3338 assert_eq!(applied, CursorGrabMode::None);
3339 assert_eq!(
3340 attempts,
3341 [
3342 WinitCursorGrabMode::Locked,
3343 WinitCursorGrabMode::Confined,
3344 WinitCursorGrabMode::None
3345 ]
3346 );
3347 }
3348
3349 #[test]
3350 fn converts_physical_size_to_logical_size() {
3351 let size = physical_size_to_logical_size(PhysicalSize::new(640, 360), 2.0);
3352
3353 assert_eq!(size.width, 320.0);
3354 assert_eq!(size.height, 180.0);
3355 }
3356
3357 #[test]
3358 fn converts_physical_pointer_position_to_logical_point() {
3359 let point = physical_position_to_logical_point(PhysicalPosition::new(240.0, 120.0), 1.5);
3360
3361 assert_eq!(point.x, 160.0);
3362 assert_eq!(point.y, 80.0);
3363 }
3364
3365 #[test]
3366 fn converts_physical_scroll_delta_to_logical_vector() {
3367 let delta = physical_position_to_logical_vector(PhysicalPosition::new(90.0, 45.0), 1.5);
3368
3369 assert_eq!(delta.x, 60.0);
3370 assert_eq!(delta.y, 30.0);
3371 }
3372
3373 #[test]
3374 fn preserves_raw_mouse_motion_without_dpi_scaling() {
3375 let delta = raw_mouse_motion_to_vector((12.5, -7.25));
3376
3377 assert_eq!(delta.x, 12.5);
3378 assert_eq!(delta.y, -7.25);
3379 }
3380
3381 #[test]
3382 fn android_back_normalization_activates_once_for_press_and_release() {
3383 let browser_back = Key::Named(NamedKey::BrowserBack);
3384 let mut down_seen = false;
3385
3386 assert_eq!(
3387 normalize_android_back_event(
3388 &browser_back,
3389 ElementState::Pressed,
3390 false,
3391 &mut down_seen,
3392 ),
3393 (ElementState::Pressed, true)
3394 );
3395 assert!(down_seen);
3396 assert_eq!(
3397 normalize_android_back_event(
3398 &browser_back,
3399 ElementState::Released,
3400 false,
3401 &mut down_seen,
3402 ),
3403 (ElementState::Released, false)
3404 );
3405 assert!(!down_seen);
3406 assert_eq!(
3407 normalize_android_back_event(
3408 &browser_back,
3409 ElementState::Pressed,
3410 true,
3411 &mut down_seen,
3412 ),
3413 (ElementState::Pressed, false)
3414 );
3415 assert_eq!(
3416 normalize_android_back_event(
3417 &Key::Named(NamedKey::Escape),
3418 ElementState::Pressed,
3419 false,
3420 &mut down_seen,
3421 ),
3422 (ElementState::Pressed, false)
3423 );
3424 }
3425
3426 #[test]
3427 fn android_back_normalization_promotes_release_only_delivery() {
3428 let mut down_seen = false;
3429 assert_eq!(
3430 normalize_android_back_event(
3431 &Key::Named(NamedKey::BrowserBack),
3432 ElementState::Released,
3433 false,
3434 &mut down_seen,
3435 ),
3436 (ElementState::Pressed, true)
3437 );
3438 assert!(!down_seen);
3439 }
3440
3441 #[test]
3442 fn web_click_prefers_advertised_non_geometric_semantics_actions() {
3443 let mut node = SemanticsNode::new(
3444 sui_core::WidgetId::new(7),
3445 SemanticsRole::Status,
3446 Rect::new(0.0, 0.0, 120.0, 32.0),
3447 );
3448 node.state.expanded = Some(false);
3449 node.actions.push(SemanticsAction::Expand);
3450 assert_eq!(
3451 web_click_semantics_action(&node),
3452 Some(SemanticsActionRequest::Expand)
3453 );
3454
3455 node.state.expanded = Some(true);
3456 node.actions = vec![SemanticsAction::Collapse];
3457 assert_eq!(
3458 web_click_semantics_action(&node),
3459 Some(SemanticsActionRequest::Collapse)
3460 );
3461
3462 node.state.expanded = None;
3463 node.actions = vec![SemanticsAction::Copy];
3464 assert_eq!(
3465 web_click_semantics_action(&node),
3466 Some(SemanticsActionRequest::Copy)
3467 );
3468 }
3469
3470 #[test]
3471 fn maps_winit_external_file_window_events() {
3472 let path = PathBuf::from(r"C:\workspace\agent.json");
3473
3474 assert_eq!(
3475 map_external_file_window_event(&WinitWindowEvent::HoveredFile(path.clone())),
3476 Some(WindowEvent::ExternalFileHovered(path.clone()))
3477 );
3478 assert_eq!(
3479 map_external_file_window_event(&WinitWindowEvent::DroppedFile(path.clone())),
3480 Some(WindowEvent::ExternalFileDropped(path))
3481 );
3482 assert_eq!(
3483 map_external_file_window_event(&WinitWindowEvent::HoveredFileCancelled),
3484 Some(WindowEvent::ExternalFileHoverCancelled)
3485 );
3486 assert_eq!(
3487 map_external_file_window_event(&WinitWindowEvent::Focused(true)),
3488 None
3489 );
3490 }
3491
3492 #[test]
3493 fn sanitize_ime_cursor_area_preserves_valid_geometry() {
3494 let (position, size) =
3495 sanitize_ime_cursor_area(Rect::new(10.0, 20.0, 4.0, 6.0), 1.5).unwrap();
3496
3497 assert_eq!(position, PhysicalPosition::new(15, 30));
3498 assert_eq!(size, PhysicalSize::new(6, 9));
3499 }
3500
3501 #[test]
3502 fn sanitize_ime_cursor_area_clamps_overflowing_geometry() {
3503 let (position, size) =
3504 sanitize_ime_cursor_area(Rect::new(f32::MAX, f32::MAX, f32::MAX, f32::MAX), 1.0)
3505 .unwrap();
3506
3507 assert_eq!(position, PhysicalPosition::new(i32::MAX - 1, i32::MAX - 1));
3508 assert_eq!(size, PhysicalSize::new(1, 1));
3509 }
3510
3511 #[test]
3512 fn sanitize_ime_cursor_area_rejects_non_finite_geometry() {
3513 assert!(sanitize_ime_cursor_area(Rect::new(f32::NAN, 0.0, 10.0, 10.0), 1.0).is_none());
3514 assert!(sanitize_ime_cursor_area(Rect::new(0.0, 0.0, f32::INFINITY, 10.0), 1.0).is_none());
3515 }
3516
3517 #[test]
3518 fn default_svg_window_icon_rasterizes_to_winit_icon() {
3519 assert!(window_icon_to_winit_icon(&WindowIcon::sui()).is_ok());
3520 }
3521
3522 #[test]
3523 fn default_svg_window_icon_rasterizes_to_bitmap() {
3524 let (width, height, rgba) =
3525 rasterize_svg_window_icon_rgba8(WindowIcon::sui().as_svg().unwrap(), 64).unwrap();
3526
3527 assert_eq!((width, height), (64, 64));
3528 assert_eq!(rgba.len(), 64 * 64 * 4);
3529 assert!(rgba.chunks_exact(4).any(|pixel| pixel[3] != 0));
3530 }
3531}