1#![forbid(unsafe_code)]
2
3mod command;
4mod diagnostics;
5mod logo;
6mod overlay;
7mod reactive;
8mod widget;
9
10use std::{
11 collections::{BTreeSet, HashMap, HashSet, VecDeque},
12 sync::{
13 Arc,
14 atomic::{AtomicU64, Ordering},
15 },
16};
17
18use sui_core::{
19 AsyncWakeToken, Clipboard, ClipboardBackend, CustomEvent, DirtyRegion, DragEvent,
20 DragEventKind, DragOutcome, DragPayload, DragScopeId, DragSessionId, DropEffect, Error, Event,
21 FontHandle, ImageHandle, InvalidationKind, InvalidationRequest, InvalidationTarget, KeyState,
22 Point, PointerButton, PointerButtons, PointerEvent, PointerEventKind, Rect, Result,
23 SemanticsActionRequest, SemanticsEvent, SemanticsNode, Size, TimerToken, Vector, WakeEvent,
24 WidgetId, WindowEvent, WindowId,
25};
26use sui_layout::Constraints;
27use sui_scene::{
28 ImageRegistry, LayerCompositionMode, RegisteredImage, Scene, SceneCommand, SceneFrame,
29 SceneLayer, SceneLayerDescriptor, SceneLayerUpdate, SceneLayerUpdateKind,
30};
31use sui_text::{FontRegistry, RegisteredFont, TextLayoutHandle, TextSystem};
32use web_time::Instant;
33
34pub use command::{
35 Command, CommandController, CommandCtx, CommandDelivery, CommandKey, CommandSender,
36 CommandTarget,
37};
38use command::{CommandInvalidation, CommandListeners, QueuedCommand};
39pub use diagnostics::{
40 CacheMetrics, CacheMetricsDelta, CommandDispatchSample, FramePhase, FramePhaseSample,
41 InvalidationTraceSample, PresentationLatencyDiagnostics, ReactiveInvalidationSample,
42 RenderDiagnostics, RendererSubmissionDiagnostics, RetainedPacketHotspotDiagnostics,
43 RetainedPacketRebuildDiagnostics, SceneStatistics, SceneStatisticsDetailMode,
44 TextCacheDeltaDiagnostics, TextCacheDiagnostics, WidgetRebuildSample, WidgetTimingPhase,
45 WidgetTimingSample, WindowColorManagementMode, WindowDynamicRangeMode,
46 WindowOutputColorPrimaries, WindowPerformanceSnapshot, WindowPerformanceSummary,
47 WindowRenderOptions, WindowStemDarkening, WindowTextCoveragePolicy, WindowTextHinting,
48 WindowTextSubpixelOrder, WindowToneMappingMode, clear_window_performance_snapshot,
49 clear_window_performance_snapshots, clear_window_render_options,
50 publish_window_performance_snapshot, set_window_render_options,
51 set_window_scene_statistics_detail_mode, window_performance_snapshot,
52 window_performance_summary, window_performance_text_caches, window_render_options,
53 window_scene_statistics_detail_mode,
54};
55pub use logo::{DEFAULT_SUI_LOGO_SVG, default_sui_logo_image};
56pub use overlay::{
57 OVERLAY_DISMISS_REQUEST, OverlayDismissPolicy, OverlayDismissReason, OverlayDismissRequest,
58 OverlayFocusBehavior, OverlayInitialFocus, OverlayKind, OverlayManagerSnapshot,
59 OverlayModality, OverlayOptions, OverlaySnapshot, OverlayTraceKind, OverlayTraceSample,
60};
61use std::rc::Rc;
62pub use sui_core::{DpiInfo, SafeAreaInsets};
63pub use sui_layout::LayoutContext;
64use widget::MeasureScope;
65pub use widget::{
66 ArrangeCtx, EventCtx, EventPhase, FocusRestorePolicy, FocusScope, FocusScopeState,
67 KeyedChildren, KeyedReconcile, LayerOptions, MeasureCtx, PaintBoundaryMode, PaintCtx,
68 SemanticsCtx, SingleChild, StackHostOptions, StackOrderPolicy, StackSurfaceOptions, Widget,
69 WidgetChildren, WidgetDiagnostic, WidgetDiagnosticsCtx, WidgetDiagnosticsSnapshot, WidgetPod,
70 WidgetPodMutVisitor, WidgetPodVisitor,
71};
72use widget::{
73 BeginDragRequest, DragRequest, DropAcceptanceRequest, FocusRequest, PaintImageResource,
74 PointerCaptureRequest, WakeRequest,
75};
76
77pub const REACTIVE_CHANGED: CommandKey<()> = CommandKey::new("sui.reactive.changed");
80
81type PaintOutput = (
82 Scene,
83 Vec<(ImageHandle, PaintImageResource)>,
84 HashMap<WidgetId, Rect>,
85 Vec<InvalidationRequest>,
86 Option<Rect>,
87);
88
89static NEXT_WINDOW_ID: AtomicU64 = AtomicU64::new(1);
90
91pub struct WindowBuilder {
92 title: String,
93 icon: Option<WindowIcon>,
94 root: Option<WidgetPod>,
95 command_listeners: CommandListeners,
96}
97
98impl WindowBuilder {
99 pub fn new() -> Self {
100 Self {
101 title: "SUI Window".to_string(),
102 icon: Some(WindowIcon::sui()),
103 root: None,
104 command_listeners: CommandListeners::default(),
105 }
106 }
107
108 pub fn title(mut self, title: impl Into<String>) -> Self {
109 self.title = title.into();
110 self
111 }
112
113 pub fn icon(mut self, icon: WindowIcon) -> Self {
114 self.icon = Some(icon);
115 self
116 }
117
118 pub fn icon_svg(mut self, svg: impl Into<Vec<u8>>) -> Self {
119 self.icon = Some(WindowIcon::from_svg(svg));
120 self
121 }
122
123 pub fn without_icon(mut self) -> Self {
124 self.icon = None;
125 self
126 }
127
128 pub fn root<W>(mut self, root: W) -> Self
129 where
130 W: Widget + 'static,
131 {
132 self.root = Some(WidgetPod::new(root));
133 self
134 }
135
136 pub fn controller(mut self, controller: impl CommandController + 'static) -> Self {
139 self.command_listeners.push_controller(controller);
140 self
141 }
142
143 pub fn on_command<T, F>(mut self, key: CommandKey<T>, handler: F) -> Self
145 where
146 T: Send + Sync + 'static,
147 F: FnMut(&mut CommandCtx, &T) + 'static,
148 {
149 self.command_listeners.push_subscription(key, handler);
150 self
151 }
152
153 fn build(self, window_id: WindowId, command_sender: CommandSender) -> Result<WindowState> {
154 let root = self
155 .root
156 .ok_or_else(|| Error::new("window root widget must be set before building"))?;
157
158 Ok(WindowState::new(
159 window_id,
160 self.title,
161 self.icon,
162 root,
163 self.command_listeners,
164 command_sender,
165 ))
166 }
167}
168
169impl Default for WindowBuilder {
170 fn default() -> Self {
171 Self::new()
172 }
173}
174
175#[derive(Debug, Clone, PartialEq, Eq)]
176pub enum WindowIcon {
177 Svg {
178 data: Arc<[u8]>,
179 },
180 Rgba8 {
181 width: u32,
182 height: u32,
183 data: Arc<[u8]>,
184 },
185}
186
187impl WindowIcon {
188 pub fn sui() -> Self {
189 Self::from_svg(DEFAULT_SUI_LOGO_SVG)
190 }
191
192 pub fn from_svg(svg: impl Into<Vec<u8>>) -> Self {
193 Self::Svg {
194 data: Arc::from(svg.into()),
195 }
196 }
197
198 pub fn from_rgba8(width: u32, height: u32, data: impl Into<Vec<u8>>) -> Result<Self> {
199 if width == 0 || height == 0 {
200 return Err(Error::new("window icon dimensions must be non-zero"));
201 }
202
203 let data = data.into();
204 let expected_len = (width as usize)
205 .checked_mul(height as usize)
206 .and_then(|pixels| pixels.checked_mul(4))
207 .ok_or_else(|| Error::new("window icon dimensions overflow RGBA buffer length"))?;
208
209 if data.len() != expected_len {
210 return Err(Error::new(format!(
211 "window icon RGBA buffer length mismatch: expected {expected_len}, got {}",
212 data.len()
213 )));
214 }
215
216 Ok(Self::Rgba8 {
217 width,
218 height,
219 data: Arc::from(data),
220 })
221 }
222
223 pub fn as_svg(&self) -> Option<&[u8]> {
224 match self {
225 Self::Svg { data } => Some(data),
226 Self::Rgba8 { .. } => None,
227 }
228 }
229
230 pub fn as_rgba8(&self) -> Option<(u32, u32, &[u8])> {
231 match self {
232 Self::Svg { .. } => None,
233 Self::Rgba8 {
234 width,
235 height,
236 data,
237 } => Some((*width, *height, data)),
238 }
239 }
240}
241
242impl Default for WindowIcon {
243 fn default() -> Self {
244 Self::sui()
245 }
246}
247
248#[derive(Debug, Clone, Copy, PartialEq, Eq)]
249pub struct EmbeddedSvgImageResource {
250 handle: ImageHandle,
251 data: &'static [u8],
252 size: Option<(u32, u32)>,
253}
254
255impl EmbeddedSvgImageResource {
256 pub const fn new(handle: ImageHandle, data: &'static [u8]) -> Self {
257 Self {
258 handle,
259 data,
260 size: None,
261 }
262 }
263
264 pub const fn at_size(
265 handle: ImageHandle,
266 width: u32,
267 height: u32,
268 data: &'static [u8],
269 ) -> Self {
270 Self {
271 handle,
272 data,
273 size: Some((width, height)),
274 }
275 }
276
277 pub const fn handle(self) -> ImageHandle {
278 self.handle
279 }
280
281 pub const fn data(self) -> &'static [u8] {
282 self.data
283 }
284
285 pub const fn size(self) -> Option<(u32, u32)> {
286 self.size
287 }
288
289 pub fn registered_image(self) -> Result<RegisteredImage> {
290 match self.size {
291 Some((width, height)) => RegisteredImage::from_svg_at_size(width, height, self.data),
292 None => RegisteredImage::from_svg(self.data),
293 }
294 }
295}
296
297pub struct Application {
298 windows: Vec<WindowBuilder>,
299 next_font_id: u64,
300 next_image_id: u64,
301 font_registry: Arc<FontRegistry>,
302 image_registry: Arc<ImageRegistry>,
303 command_listeners: CommandListeners,
304}
305
306impl Application {
307 pub fn new() -> Self {
308 Self::default()
309 }
310
311 pub fn window(mut self, window: WindowBuilder) -> Self {
312 self.windows.push(window);
313 self
314 }
315
316 pub fn controller(mut self, controller: impl CommandController + 'static) -> Self {
318 self.command_listeners.push_controller(controller);
319 self
320 }
321
322 pub fn on_command<T, F>(mut self, key: CommandKey<T>, handler: F) -> Self
324 where
325 T: Send + Sync + 'static,
326 F: FnMut(&mut CommandCtx, &T) + 'static,
327 {
328 self.command_listeners.push_subscription(key, handler);
329 self
330 }
331
332 pub fn register_font(&mut self, handle: FontHandle, font: RegisteredFont) -> Result<()> {
333 if Arc::make_mut(&mut self.font_registry)
334 .insert(handle, font)
335 .is_some()
336 {
337 return Err(Error::new(format!(
338 "font handle {} is already registered",
339 handle.get()
340 )));
341 }
342
343 self.next_font_id = self.next_font_id.max(handle.get() + 1);
344 Ok(())
345 }
346
347 pub fn register_font_bytes(&mut self, data: impl Into<Vec<u8>>) -> Result<FontHandle> {
348 let handle = FontHandle::new(self.next_font_id.max(1));
349 self.next_font_id = handle.get() + 1;
350 self.register_font(handle, RegisteredFont::from_bytes(data))?;
351 Ok(handle)
352 }
353
354 pub fn register_image(&mut self, handle: ImageHandle, image: RegisteredImage) -> Result<()> {
355 if Arc::make_mut(&mut self.image_registry)
356 .insert(handle, image)
357 .is_some()
358 {
359 return Err(Error::new(format!(
360 "image handle {} is already registered",
361 handle.get()
362 )));
363 }
364
365 self.next_image_id = self.next_image_id.max(handle.get() + 1);
366 Ok(())
367 }
368
369 pub fn register_svg_image_with_handle(
370 &mut self,
371 handle: ImageHandle,
372 data: impl AsRef<[u8]>,
373 ) -> Result<()> {
374 self.register_image(handle, RegisteredImage::from_svg(data)?)
375 }
376
377 pub fn register_rgba_image(
378 &mut self,
379 width: u32,
380 height: u32,
381 data: impl Into<Vec<u8>>,
382 ) -> Result<ImageHandle> {
383 let handle = ImageHandle::new(self.next_image_id.max(1));
384 self.next_image_id = handle.get() + 1;
385 self.register_image(handle, RegisteredImage::from_rgba8(width, height, data)?)?;
386 Ok(handle)
387 }
388
389 pub fn register_svg_image(&mut self, data: impl AsRef<[u8]>) -> Result<ImageHandle> {
390 let handle = ImageHandle::new(self.next_image_id.max(1));
391 self.next_image_id = handle.get() + 1;
392 self.register_image(handle, RegisteredImage::from_svg(data)?)?;
393 Ok(handle)
394 }
395
396 pub fn register_svg_image_at_size_with_handle(
397 &mut self,
398 handle: ImageHandle,
399 width: u32,
400 height: u32,
401 data: impl AsRef<[u8]>,
402 ) -> Result<()> {
403 self.register_image(
404 handle,
405 RegisteredImage::from_svg_at_size(width, height, data)?,
406 )
407 }
408
409 pub fn register_svg_image_at_size(
410 &mut self,
411 width: u32,
412 height: u32,
413 data: impl AsRef<[u8]>,
414 ) -> Result<ImageHandle> {
415 let handle = ImageHandle::new(self.next_image_id.max(1));
416 self.next_image_id = handle.get() + 1;
417 self.register_image(
418 handle,
419 RegisteredImage::from_svg_at_size(width, height, data)?,
420 )?;
421 Ok(handle)
422 }
423
424 pub fn register_embedded_svg_image(
425 &mut self,
426 resource: EmbeddedSvgImageResource,
427 ) -> Result<()> {
428 self.register_image(resource.handle(), resource.registered_image()?)
429 }
430
431 pub fn register_embedded_svg_images(
432 &mut self,
433 resources: impl IntoIterator<Item = EmbeddedSvgImageResource>,
434 ) -> Result<()> {
435 for resource in resources {
436 self.register_embedded_svg_image(resource)?;
437 }
438 Ok(())
439 }
440
441 pub fn build(self) -> Result<Runtime> {
442 let mut runtime = Runtime::with_registries(
443 self.next_font_id,
444 self.font_registry,
445 self.next_image_id,
446 self.image_registry,
447 );
448 runtime.command_listeners = self.command_listeners;
449
450 for window in self.windows {
451 runtime.add_window(window)?;
452 }
453
454 Ok(runtime)
455 }
456}
457
458impl Default for Application {
459 fn default() -> Self {
460 Self {
461 windows: Vec::new(),
462 next_font_id: 1,
463 next_image_id: 1,
464 font_registry: Arc::new(FontRegistry::new()),
465 image_registry: Arc::new(ImageRegistry::new()),
466 command_listeners: CommandListeners::default(),
467 }
468 }
469}
470
471pub const EXTERNAL_WAKE_KIND: &str = "sui.external.wake";
474
475pub struct Runtime {
476 next_font_id: u64,
477 next_image_id: u64,
478 font_registry: Arc<FontRegistry>,
479 image_registry: Arc<ImageRegistry>,
480 text_system: Arc<TextSystem>,
481 clipboard: Clipboard,
482 windows: Vec<WindowState>,
483 external_waker: Option<Arc<dyn Fn() + Send + Sync>>,
484 command_sender: CommandSender,
485 command_listeners: CommandListeners,
486}
487
488impl Runtime {
489 pub fn new() -> Self {
490 Self::with_registries(
491 1,
492 Arc::new(FontRegistry::new()),
493 1,
494 Arc::new(ImageRegistry::new()),
495 )
496 }
497
498 fn with_registries(
499 next_font_id: u64,
500 font_registry: Arc<FontRegistry>,
501 next_image_id: u64,
502 image_registry: Arc<ImageRegistry>,
503 ) -> Self {
504 Self {
505 next_font_id: next_font_id.max(1),
506 next_image_id: next_image_id.max(1),
507 font_registry,
508 image_registry,
509 text_system: Arc::new(TextSystem::new()),
510 clipboard: Clipboard::new(),
511 windows: Vec::new(),
512 external_waker: None,
513 command_sender: CommandSender::new(),
514 command_listeners: CommandListeners::default(),
515 }
516 }
517
518 pub fn add_window(&mut self, builder: WindowBuilder) -> Result<WindowId> {
519 let window_id = self.alloc_window_id();
520 let mut window = builder.build(window_id, self.command_sender.clone())?;
521 window.clipboard = self.clipboard.clone();
522 window.reactive_hub.set_waker(self.external_waker.clone());
523 self.windows.push(window);
524 Ok(window_id)
525 }
526
527 pub fn set_external_waker(&mut self, waker: impl Fn() + Send + Sync + 'static) {
530 let waker: Arc<dyn Fn() + Send + Sync> = Arc::new(waker);
531 self.external_waker = Some(Arc::clone(&waker));
532 for window in &self.windows {
533 window.reactive_hub.set_waker(Some(Arc::clone(&waker)));
534 }
535 }
536
537 pub fn set_command_waker(&self, waker: impl Fn() + Send + Sync + 'static) {
539 self.command_sender.set_waker(Some(Arc::new(waker)));
540 }
541
542 pub fn command_sender(&self) -> CommandSender {
544 self.command_sender.clone()
545 }
546
547 pub fn has_pending_commands(&self) -> bool {
548 self.command_sender.has_pending()
549 }
550
551 pub fn process_reactive_updates(&mut self) {
556 for window in &mut self.windows {
557 window.drain_reactive_invalidations();
558 }
559 }
560
561 pub fn process_commands(&mut self) {
566 const MAX_COMMAND_ROUNDS: usize = 8;
567
568 for _ in 0..MAX_COMMAND_ROUNDS {
569 let (manual_wake, commands) = self.command_sender.drain();
570 if !manual_wake && commands.is_empty() {
571 break;
572 }
573 if manual_wake {
574 self.dispatch_controller_wake();
575 }
576 for command in commands {
577 self.dispatch_queued_command(&command);
578 }
579 }
580 }
581
582 pub fn handle_command<T>(
585 &mut self,
586 target: CommandTarget,
587 delivery: CommandDelivery,
588 key: CommandKey<T>,
589 payload: T,
590 ) where
591 T: Send + Sync + 'static,
592 {
593 match delivery {
594 CommandDelivery::Directed => self.command_sender.send(target, key, payload),
595 CommandDelivery::Broadcast => self.command_sender.broadcast(target, key, payload),
596 }
597 self.process_commands();
598 }
599
600 pub fn clipboard(&self) -> Clipboard {
602 self.clipboard.clone()
603 }
604
605 pub fn set_clipboard_backend(&self, backend: impl ClipboardBackend + 'static) {
608 self.clipboard.set_backend(backend);
609 }
610
611 pub fn remove_window(&mut self, window_id: WindowId) -> Result<()> {
612 let Some(window_index) = self
613 .windows
614 .iter()
615 .position(|window| window.id == window_id)
616 else {
617 return Err(Error::new(format!(
618 "window {} does not exist",
619 window_id.get()
620 )));
621 };
622
623 self.windows.remove(window_index);
624 clear_window_performance_snapshot(window_id);
625 Ok(())
626 }
627
628 pub fn handle_event(&mut self, window_id: WindowId, event: Event) -> Result<()> {
629 self.dispatch_event(window_id, event).map(|_| ())
630 }
631
632 pub fn dispatch_event(&mut self, window_id: WindowId, event: Event) -> Result<bool> {
639 let text_system = Arc::clone(&self.text_system);
640 let font_registry = Arc::clone(&self.font_registry);
641 let image_registry = Arc::clone(&self.image_registry);
642 let window = self.window_mut(window_id)?;
643 window.drain_reactive_invalidations();
644 let handled = window.handle_event(event, text_system, font_registry, image_registry);
645 window.drain_reactive_invalidations();
646 Ok(handled)
647 }
648
649 pub fn handle_semantics_action(
658 &mut self,
659 window_id: WindowId,
660 target: WidgetId,
661 action: SemanticsActionRequest,
662 ) -> Result<bool> {
663 let text_system = Arc::clone(&self.text_system);
664 let font_registry = Arc::clone(&self.font_registry);
665 let image_registry = Arc::clone(&self.image_registry);
666 let window = self.window_mut(window_id)?;
667 Ok(window.handle_semantics_action(
668 target,
669 action,
670 text_system,
671 font_registry,
672 image_registry,
673 ))
674 }
675
676 pub fn tick(&mut self, frame_time: f64) {
677 for window in &mut self.windows {
678 window.last_tick_time = frame_time;
679 }
680 }
681
682 pub fn drain_ready_events(&mut self) -> Vec<(WindowId, Event)> {
683 let mut ready = Vec::new();
684
685 for window in &mut self.windows {
686 let window_id = window.id;
687 ready.extend(
688 window
689 .drain_ready_events()
690 .into_iter()
691 .map(|event| (window_id, event)),
692 );
693 }
694
695 ready
696 }
697
698 pub fn next_wakeup_time(&self, window_id: WindowId) -> Result<Option<f64>> {
699 let window = self.window(window_id)?;
700 Ok(window.next_wakeup_time())
701 }
702
703 pub fn wake_async(&mut self, window_id: WindowId, token: AsyncWakeToken) -> Result<bool> {
704 let window = self.window_mut(window_id)?;
705 Ok(window.wake_async(token))
706 }
707
708 pub fn wake_root(&mut self, window_id: WindowId) -> Result<()> {
714 self.handle_event(
715 window_id,
716 Event::Custom(CustomEvent::new(EXTERNAL_WAKE_KIND)),
717 )
718 }
719
720 pub fn register_font(&mut self, handle: FontHandle, font: RegisteredFont) -> Result<()> {
721 if Arc::make_mut(&mut self.font_registry)
722 .insert(handle, font)
723 .is_some()
724 {
725 return Err(Error::new(format!(
726 "font handle {} is already registered",
727 handle.get()
728 )));
729 }
730
731 self.next_font_id = self.next_font_id.max(handle.get() + 1);
732 Ok(())
733 }
734
735 pub fn register_font_bytes(&mut self, data: impl Into<Vec<u8>>) -> Result<FontHandle> {
736 let handle = FontHandle::new(self.next_font_id.max(1));
737 self.next_font_id = handle.get() + 1;
738 self.register_font(handle, RegisteredFont::from_bytes(data))?;
739 Ok(handle)
740 }
741
742 pub fn register_image(&mut self, handle: ImageHandle, image: RegisteredImage) -> Result<()> {
743 if Arc::make_mut(&mut self.image_registry)
744 .insert(handle, image)
745 .is_some()
746 {
747 return Err(Error::new(format!(
748 "image handle {} is already registered",
749 handle.get()
750 )));
751 }
752
753 self.next_image_id = self.next_image_id.max(handle.get() + 1);
754 Ok(())
755 }
756
757 pub fn register_svg_image_with_handle(
758 &mut self,
759 handle: ImageHandle,
760 data: impl AsRef<[u8]>,
761 ) -> Result<()> {
762 self.register_image(handle, RegisteredImage::from_svg(data)?)
763 }
764
765 pub fn register_rgba_image(
766 &mut self,
767 width: u32,
768 height: u32,
769 data: impl Into<Vec<u8>>,
770 ) -> Result<ImageHandle> {
771 let handle = ImageHandle::new(self.next_image_id.max(1));
772 self.next_image_id = handle.get() + 1;
773 self.register_image(handle, RegisteredImage::from_rgba8(width, height, data)?)?;
774 Ok(handle)
775 }
776
777 pub fn register_svg_image(&mut self, data: impl AsRef<[u8]>) -> Result<ImageHandle> {
778 let handle = ImageHandle::new(self.next_image_id.max(1));
779 self.next_image_id = handle.get() + 1;
780 self.register_image(handle, RegisteredImage::from_svg(data)?)?;
781 Ok(handle)
782 }
783
784 pub fn register_svg_image_at_size_with_handle(
785 &mut self,
786 handle: ImageHandle,
787 width: u32,
788 height: u32,
789 data: impl AsRef<[u8]>,
790 ) -> Result<()> {
791 self.register_image(
792 handle,
793 RegisteredImage::from_svg_at_size(width, height, data)?,
794 )
795 }
796
797 pub fn register_svg_image_at_size(
798 &mut self,
799 width: u32,
800 height: u32,
801 data: impl AsRef<[u8]>,
802 ) -> Result<ImageHandle> {
803 let handle = ImageHandle::new(self.next_image_id.max(1));
804 self.next_image_id = handle.get() + 1;
805 self.register_image(
806 handle,
807 RegisteredImage::from_svg_at_size(width, height, data)?,
808 )?;
809 Ok(handle)
810 }
811
812 pub fn register_embedded_svg_image(
813 &mut self,
814 resource: EmbeddedSvgImageResource,
815 ) -> Result<()> {
816 self.register_image(resource.handle(), resource.registered_image()?)
817 }
818
819 pub fn register_embedded_svg_images(
820 &mut self,
821 resources: impl IntoIterator<Item = EmbeddedSvgImageResource>,
822 ) -> Result<()> {
823 for resource in resources {
824 self.register_embedded_svg_image(resource)?;
825 }
826 Ok(())
827 }
828
829 pub fn font_registry(&self) -> &Arc<FontRegistry> {
830 &self.font_registry
831 }
832
833 pub fn image_registry(&self) -> &Arc<ImageRegistry> {
834 &self.image_registry
835 }
836
837 pub fn render(&mut self, window_id: WindowId) -> Result<RenderOutput> {
838 let text_system = Arc::clone(&self.text_system);
839 let font_registry = Arc::clone(&self.font_registry);
840 let image_registry = Arc::clone(&self.image_registry);
841 let window = self.window_mut(window_id)?;
842 window.drain_reactive_invalidations();
843 Ok(window.render(text_system, font_registry, image_registry))
844 }
845
846 pub fn semantics(&self, window_id: WindowId) -> Result<&[SemanticsNode]> {
847 let window = self.window(window_id)?;
848 Ok(&window.last_semantics)
849 }
850
851 pub fn window_title(&self, window_id: WindowId) -> Result<&str> {
852 let window = self.window(window_id)?;
853 Ok(&window.title)
854 }
855
856 pub fn window_icon(&self, window_id: WindowId) -> Result<Option<&WindowIcon>> {
857 let window = self.window(window_id)?;
858 Ok(window.icon.as_ref())
859 }
860
861 pub fn window_ids(&self) -> Vec<WindowId> {
862 self.windows.iter().map(|window| window.id).collect()
863 }
864
865 pub fn needs_render(&self, window_id: WindowId) -> Result<bool> {
866 let window = self.window(window_id)?;
867 Ok(window.needs_render())
868 }
869
870 pub fn schedule(&self, window_id: WindowId) -> Result<FrameSchedule> {
871 let window = self.window(window_id)?;
872 Ok(window.schedule)
873 }
874
875 pub fn focus_state(&self, window_id: WindowId) -> Result<FocusState> {
876 let window = self.window(window_id)?;
877 Ok(window.focus)
878 }
879
880 pub fn focused_widget(&self, window_id: WindowId) -> Result<Option<WidgetId>> {
881 Ok(self.focus_state(window_id)?.focused_widget)
882 }
883
884 pub fn pointer_capture_target(
885 &self,
886 window_id: WindowId,
887 pointer_id: u64,
888 ) -> Result<Option<WidgetId>> {
889 let window = self.window(window_id)?;
890 Ok(window.pointer_capture.get(&pointer_id).copied())
891 }
892
893 pub fn widget_graph(&self, window_id: WindowId) -> Result<WidgetGraphSnapshot> {
894 let window = self.window(window_id)?;
895 Ok(window.graph.snapshot())
896 }
897
898 pub fn set_inspector_tracing(&mut self, window_id: WindowId, enabled: bool) -> Result<()> {
901 let window = self.window_mut(window_id)?;
902 if window.inspector_tracing_enabled != enabled {
903 window.clear_inspector_history();
904 window.last_render_diagnostics = RenderDiagnostics::default();
905 }
906 window.inspector_tracing_enabled = enabled;
907 Ok(())
908 }
909
910 pub fn inspector_tracing(&self, window_id: WindowId) -> Result<bool> {
911 Ok(self.window(window_id)?.inspector_tracing_enabled)
912 }
913
914 pub fn inspector_snapshot(&self, window_id: WindowId) -> Result<WindowInspectorSnapshot> {
916 let window = self.window(window_id)?;
917 Ok(window.inspector_snapshot())
918 }
919
920 pub fn overlay_snapshot(&self, window_id: WindowId) -> Result<OverlayManagerSnapshot> {
922 let window = self.window(window_id)?;
923 Ok(window.overlay_manager.snapshot())
924 }
925
926 pub fn take_overlay_traces(&mut self, window_id: WindowId) -> Result<Vec<OverlayTraceSample>> {
928 let window = self.window_mut(window_id)?;
929 Ok(window.overlay_manager.take_traces())
930 }
931
932 fn dispatch_controller_wake(&mut self) {
933 let sender = self.command_sender.clone();
934 let mut app_ctx = CommandCtx::new(sender.clone(), None);
935 let app_handlers = self.command_listeners.wake(&mut app_ctx);
936 self.apply_command_ctx(
937 app_ctx,
938 "scheduler wake",
939 "()",
940 None,
941 0,
942 CommandTarget::Application,
943 CommandDelivery::Broadcast,
944 app_handlers,
945 );
946
947 for index in 0..self.windows.len() {
948 let window_id = self.windows[index].id;
949 let mut ctx = CommandCtx::new(sender.clone(), Some(window_id));
950 let handlers = self.windows[index].command_listeners.wake(&mut ctx);
951 self.apply_command_ctx(
952 ctx,
953 "scheduler wake",
954 "()",
955 Some(index),
956 0,
957 CommandTarget::Window(window_id),
958 CommandDelivery::Broadcast,
959 handlers,
960 );
961 }
962 }
963
964 fn dispatch_queued_command(&mut self, queued: &QueuedCommand) {
965 match queued.target {
966 CommandTarget::Widget {
967 window_id,
968 widget_id,
969 } => {
970 if let Some(index) = self
971 .windows
972 .iter()
973 .position(|window| window.id == window_id)
974 {
975 let Some(dispatch) =
976 self.windows[index].dispatch_direct_command(widget_id, queued)
977 else {
978 push_trace(
979 &mut self.windows[index].pending_command_diagnostics,
980 command_sample(queued, Vec::new(), false, false),
981 );
982 return;
983 };
984 let (handlers, handled) = {
985 let handled = dispatch.handled;
986 (vec!["widget target".to_string()], handled)
987 };
988 let focus_request = dispatch.focus_request;
989 let mut effects = EventEffects::default();
990 effects.extend(dispatch);
991 let mut invalidations = Vec::new();
992 self.windows[index].apply_event_effects(effects, &mut invalidations);
993 if let Some(request) = focus_request {
994 let focus_effects = self.windows[index].apply_focus_request(request);
995 self.windows[index].apply_event_effects(focus_effects, &mut invalidations);
996 }
997 self.windows[index].record_command_invalidations(
998 &invalidations,
999 queued.key.name,
1000 None,
1001 );
1002 self.windows[index].schedule.extend(&invalidations);
1003 self.windows[index]
1004 .pending_invalidations
1005 .extend(invalidations);
1006 push_trace(
1007 &mut self.windows[index].pending_command_diagnostics,
1008 command_sample(queued, handlers, handled, true),
1009 );
1010 }
1011 }
1012 CommandTarget::FocusedWidget(window_id) => {
1013 if let Some(index) = self
1014 .windows
1015 .iter()
1016 .position(|window| window.id == window_id)
1017 {
1018 let Some(target) = self.windows[index].focus.focused_widget else {
1019 push_trace(
1020 &mut self.windows[index].pending_command_diagnostics,
1021 command_sample(queued, Vec::new(), false, false),
1022 );
1023 return;
1024 };
1025 let Some(dispatch) =
1026 self.windows[index].dispatch_direct_command(target, queued)
1027 else {
1028 push_trace(
1029 &mut self.windows[index].pending_command_diagnostics,
1030 command_sample(queued, Vec::new(), false, false),
1031 );
1032 return;
1033 };
1034 let handled = { dispatch.handled };
1035 let focus_request = dispatch.focus_request;
1036 let mut effects = EventEffects::default();
1037 effects.extend(dispatch);
1038 let mut invalidations = Vec::new();
1039 self.windows[index].apply_event_effects(effects, &mut invalidations);
1040 if let Some(request) = focus_request {
1041 let focus_effects = self.windows[index].apply_focus_request(request);
1042 self.windows[index].apply_event_effects(focus_effects, &mut invalidations);
1043 }
1044 self.windows[index].record_command_invalidations(
1045 &invalidations,
1046 queued.key.name,
1047 None,
1048 );
1049 self.windows[index].schedule.extend(&invalidations);
1050 self.windows[index]
1051 .pending_invalidations
1052 .extend(invalidations);
1053 push_trace(
1054 &mut self.windows[index].pending_command_diagnostics,
1055 command_sample(queued, vec!["focused widget".to_string()], handled, true),
1056 );
1057 }
1058 }
1059 CommandTarget::Window(window_id) => {
1060 if let Some(index) = self
1061 .windows
1062 .iter()
1063 .position(|window| window.id == window_id)
1064 {
1065 self.dispatch_to_window_listeners(index, queued);
1066 }
1067 }
1068 CommandTarget::Application => {
1069 let sender = self.command_sender.clone();
1070 let mut ctx = CommandCtx::new(sender.clone(), None);
1071 let broadcast = queued.delivery == CommandDelivery::Broadcast;
1072 let command = Command::new(queued);
1073 let handlers = self
1074 .command_listeners
1075 .dispatch(&mut ctx, &command, broadcast);
1076 self.apply_command_ctx(
1077 ctx,
1078 queued.key.name,
1079 queued.key.payload_type_name,
1080 None,
1081 queued.sequence,
1082 queued.target,
1083 queued.delivery,
1084 handlers,
1085 );
1086
1087 if broadcast {
1088 for index in 0..self.windows.len() {
1089 self.dispatch_to_window_listeners(index, queued);
1090 }
1091 }
1092 }
1093 }
1094 }
1095
1096 fn dispatch_to_window_listeners(&mut self, index: usize, queued: &QueuedCommand) {
1097 let sender = self.command_sender.clone();
1098 let window_id = self.windows[index].id;
1099 let mut ctx = CommandCtx::new(sender, Some(window_id));
1100 let broadcast = queued.delivery == CommandDelivery::Broadcast;
1101 let command = Command::new(queued);
1102 let handlers = self.windows[index]
1103 .command_listeners
1104 .dispatch(&mut ctx, &command, broadcast);
1105 self.apply_command_ctx(
1106 ctx,
1107 queued.key.name,
1108 queued.key.payload_type_name,
1109 Some(index),
1110 queued.sequence,
1111 queued.target,
1112 queued.delivery,
1113 handlers,
1114 );
1115 }
1116
1117 #[allow(clippy::too_many_arguments)]
1118 fn apply_command_ctx(
1119 &mut self,
1120 mut ctx: CommandCtx,
1121 source: &str,
1122 payload_type: &str,
1123 delivery_window: Option<usize>,
1124 sequence: u64,
1125 target: CommandTarget,
1126 delivery: CommandDelivery,
1127 handlers: Vec<String>,
1128 ) {
1129 let handled = ctx.is_handled();
1130 let invalidations = ctx.take_invalidations();
1131 let animations = ctx.take_animation_targets();
1132 for invalidation in invalidations {
1133 self.apply_command_invalidation(invalidation, source, delivery_window);
1134 }
1135 for (window_id, widget_id) in animations {
1136 if let Some(window) = self
1137 .windows
1138 .iter_mut()
1139 .find(|window| window.id == window_id)
1140 {
1141 window.requested_animation_frames.insert(widget_id);
1142 }
1143 }
1144
1145 let sample = CommandDispatchSample {
1146 sequence,
1147 name: source.to_string(),
1148 payload_type: payload_type.to_string(),
1149 target,
1150 delivery,
1151 delivered: !handlers.is_empty(),
1152 handlers,
1153 handled,
1154 };
1155 if let Some(index) = delivery_window {
1156 push_trace(&mut self.windows[index].pending_command_diagnostics, sample);
1157 } else {
1158 for window in &mut self.windows {
1159 push_trace(&mut window.pending_command_diagnostics, sample.clone());
1160 }
1161 }
1162 }
1163
1164 fn apply_command_invalidation(
1165 &mut self,
1166 invalidation: CommandInvalidation,
1167 source: &str,
1168 delivery_window: Option<usize>,
1169 ) {
1170 let target_index = match invalidation.request.target {
1171 InvalidationTarget::Window(window_id) => self
1172 .windows
1173 .iter()
1174 .position(|window| window.id == window_id),
1175 InvalidationTarget::Widget(widget_id) => self.windows.iter().position(|window| {
1176 window.root.id() == widget_id || window.graph.contains(widget_id)
1177 }),
1178 InvalidationTarget::Surface(_) => delivery_window,
1179 };
1180 let Some(index) = target_index else {
1181 return;
1182 };
1183 let request = invalidation.request;
1184 push_trace(
1185 &mut self.windows[index].pending_invalidation_diagnostics,
1186 InvalidationTraceSample {
1187 target: request.target,
1188 kind: request.kind,
1189 region: request.region,
1190 source: format!("command:{source}"),
1191 reason: invalidation.reason,
1192 },
1193 );
1194 self.windows[index]
1195 .schedule
1196 .extend(std::slice::from_ref(&request));
1197 self.windows[index].pending_invalidations.push(request);
1198 }
1199
1200 fn alloc_window_id(&mut self) -> WindowId {
1201 WindowId::new(NEXT_WINDOW_ID.fetch_add(1, Ordering::Relaxed))
1202 }
1203
1204 fn window(&self, window_id: WindowId) -> Result<&WindowState> {
1205 self.windows
1206 .iter()
1207 .find(|window| window.id == window_id)
1208 .ok_or_else(|| Error::new(format!("window {} does not exist", window_id.get())))
1209 }
1210
1211 fn window_mut(&mut self, window_id: WindowId) -> Result<&mut WindowState> {
1212 self.windows
1213 .iter_mut()
1214 .find(|window| window.id == window_id)
1215 .ok_or_else(|| Error::new(format!("window {} does not exist", window_id.get())))
1216 }
1217}
1218
1219impl Default for Runtime {
1220 fn default() -> Self {
1221 Self::new()
1222 }
1223}
1224
1225#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
1226pub struct FocusState {
1227 pub focused_widget: Option<WidgetId>,
1228 pub window_focused: bool,
1229}
1230
1231#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
1232pub struct FrameSchedule {
1233 pub measure: bool,
1234 pub arrange: bool,
1235 pub ordering: bool,
1236 pub paint: bool,
1237 pub semantics: bool,
1238 pub hit_test: bool,
1239 pub text: bool,
1240 pub resources: bool,
1241}
1242
1243impl FrameSchedule {
1244 fn bootstrap() -> Self {
1245 Self {
1246 measure: true,
1247 arrange: true,
1248 ordering: false,
1249 paint: true,
1250 semantics: true,
1251 hit_test: true,
1252 text: false,
1253 resources: false,
1254 }
1255 }
1256
1257 pub const fn any(self) -> bool {
1258 self.measure
1259 || self.arrange
1260 || self.ordering
1261 || self.paint
1262 || self.semantics
1263 || self.hit_test
1264 || self.text
1265 || self.resources
1266 }
1267
1268 pub const fn needs_render(self) -> bool {
1269 self.measure
1270 || self.arrange
1271 || self.ordering
1272 || self.paint
1273 || self.semantics
1274 || self.text
1275 || self.resources
1276 }
1277
1278 fn clear(&mut self) {
1279 *self = Self::default();
1280 }
1281
1282 fn mark(&mut self, kind: InvalidationKind) {
1283 match kind {
1284 InvalidationKind::Measure => {
1285 self.measure = true;
1286 self.arrange = true;
1287 self.ordering = true;
1288 self.paint = true;
1289 self.hit_test = true;
1290 self.semantics = true;
1291 }
1292 InvalidationKind::Arrange
1293 | InvalidationKind::Transform
1294 | InvalidationKind::Clip
1295 | InvalidationKind::Visibility => {
1296 self.ordering = true;
1297 self.arrange = true;
1298 self.paint = true;
1299 self.hit_test = true;
1300 self.semantics = true;
1301 }
1302 InvalidationKind::Ordering => {
1303 self.ordering = true;
1304 self.hit_test = true;
1305 }
1306 InvalidationKind::Effect => {
1307 self.paint = true;
1308 }
1309 InvalidationKind::Paint => {
1310 self.paint = true;
1311 }
1312 InvalidationKind::HitTest => {
1313 self.hit_test = true;
1314 }
1315 InvalidationKind::Text => {
1316 self.text = true;
1317 self.measure = true;
1318 self.arrange = true;
1319 self.paint = true;
1320 self.semantics = true;
1321 }
1322 InvalidationKind::Semantics => {
1323 self.semantics = true;
1324 }
1325 InvalidationKind::Resources => {
1326 self.resources = true;
1327 self.paint = true;
1328 }
1329 }
1330 }
1331
1332 fn extend(&mut self, invalidations: &[InvalidationRequest]) {
1333 for request in invalidations {
1334 self.mark(request.kind);
1335 }
1336 }
1337}
1338
1339#[derive(Debug, Clone, PartialEq)]
1340pub struct WidgetGeometrySnapshot {
1341 pub layout_bounds: Rect,
1342 pub input_bounds: Rect,
1343 pub paint_bounds: Rect,
1344}
1345
1346impl WidgetGeometrySnapshot {
1347 pub const fn new(layout_bounds: Rect, input_bounds: Rect, paint_bounds: Rect) -> Self {
1348 Self {
1349 layout_bounds,
1350 input_bounds,
1351 paint_bounds,
1352 }
1353 }
1354}
1355
1356#[derive(Debug, Clone, PartialEq)]
1357pub struct WidgetNodeSnapshot {
1358 pub id: WidgetId,
1359 pub widget_name: &'static str,
1360 pub parent: Option<WidgetId>,
1361 pub children: Vec<WidgetId>,
1362 pub measured_size: Size,
1363 pub geometry: WidgetGeometrySnapshot,
1364 pub bounds: Rect,
1366 pub paint_boundary: PaintBoundaryMode,
1367 pub stack_host: WidgetId,
1368 pub stack_surface: WidgetId,
1369 pub stack_surface_order: usize,
1370 pub transient_owner_surface: Option<WidgetId>,
1371 pub overlay_owner: Option<WidgetId>,
1373 pub is_overlay_owner: bool,
1374 pub is_stack_host: bool,
1375 pub is_stack_surface: bool,
1376 pub hit_test: bool,
1377 pub stack_order_policy: StackOrderPolicy,
1378 pub accepts_focus: bool,
1379 pub focused: bool,
1380}
1381
1382#[derive(Debug, Clone, PartialEq)]
1383pub struct StackHostSnapshot {
1384 pub host: WidgetId,
1385 pub order_policy: StackOrderPolicy,
1386 pub surfaces: Vec<WidgetId>,
1387}
1388
1389#[derive(Debug, Clone, PartialEq)]
1390pub struct WidgetGraphSnapshot {
1391 pub root: WidgetId,
1392 pub nodes: Vec<WidgetNodeSnapshot>,
1393 pub stack_hosts: Vec<StackHostSnapshot>,
1394}
1395
1396#[derive(Debug, Clone, Copy, PartialEq, Eq)]
1397pub enum EventRoutePhase {
1398 Capture,
1399 Target,
1400 Bubble,
1401}
1402
1403#[derive(Debug, Clone, Copy, PartialEq, Eq)]
1404pub struct EventRouteStep {
1405 pub widget_id: WidgetId,
1406 pub phase: EventRoutePhase,
1407 pub handled: bool,
1408}
1409
1410#[derive(Debug, Clone, PartialEq, Eq)]
1413pub struct EventRouteTraceSample {
1414 pub sequence: u64,
1415 pub event_kind: &'static str,
1416 pub target: WidgetId,
1417 pub path: Vec<WidgetId>,
1418 pub steps: Vec<EventRouteStep>,
1419 pub handled: bool,
1420}
1421
1422#[derive(Debug, Clone, Copy, PartialEq)]
1423pub struct TimerInspectorSnapshot {
1424 pub token: TimerToken,
1425 pub target: WidgetId,
1426 pub deadline: f64,
1427 pub delivering: bool,
1428}
1429
1430#[derive(Debug, Clone, Copy, PartialEq, Eq)]
1431pub struct AsyncTaskInspectorSnapshot {
1432 pub token: AsyncWakeToken,
1433 pub target: WidgetId,
1434 pub pending_wake: bool,
1435}
1436
1437#[derive(Debug, Clone, PartialEq, Default)]
1438pub struct SchedulerInspectorSnapshot {
1439 pub timers: Vec<TimerInspectorSnapshot>,
1440 pub async_tasks: Vec<AsyncTaskInspectorSnapshot>,
1441 pub requested_animation_frames: Vec<WidgetId>,
1442 pub delivering_animation_frames: Vec<WidgetId>,
1443 pub last_animation_frame_time: Option<f64>,
1444}
1445
1446#[derive(Debug, Clone, PartialEq, Default)]
1447pub struct InspectorHistorySnapshot {
1448 pub event_routes: Vec<EventRouteTraceSample>,
1449 pub reactive_invalidations: Vec<ReactiveInvalidationSample>,
1450 pub command_dispatches: Vec<CommandDispatchSample>,
1451 pub invalidations: Vec<InvalidationTraceSample>,
1452 pub widget_rebuilds: Vec<WidgetRebuildSample>,
1453}
1454
1455#[derive(Debug, Clone, PartialEq)]
1459pub struct WindowInspectorSnapshot {
1460 pub window_id: WindowId,
1461 pub title: String,
1462 pub tracing_enabled: bool,
1463 pub focus_state: FocusState,
1464 pub schedule: FrameSchedule,
1465 pub semantics: Vec<SemanticsNode>,
1466 pub widget_graph: WidgetGraphSnapshot,
1467 pub overlays: OverlayManagerSnapshot,
1468 pub scheduler: SchedulerInspectorSnapshot,
1469 pub widget_diagnostics: Vec<WidgetDiagnosticsSnapshot>,
1470 pub last_render_diagnostics: RenderDiagnostics,
1471 pub history: InspectorHistorySnapshot,
1472 pub scene: Option<SceneStatistics>,
1473}
1474
1475#[derive(Debug, Clone, Copy, PartialEq)]
1476struct ScheduledTimer {
1477 token: TimerToken,
1478 deadline: f64,
1479 target: WidgetId,
1480}
1481
1482#[derive(Debug, Clone, Copy, PartialEq)]
1483struct LayerTranslation {
1484 widget_id: WidgetId,
1485 delta: Vector,
1486}
1487
1488#[derive(Debug, Clone, PartialEq)]
1489struct LayerDescriptorRefresh {
1490 widget_id: WidgetId,
1491 descriptor: SceneLayerDescriptor,
1492}
1493
1494#[derive(Debug, Default)]
1495struct GraphChangeSet {
1496 repaint_widgets: Vec<WidgetId>,
1497 transform_widgets: Vec<LayerTranslation>,
1498}
1499
1500const ANIMATION_FRAME_INTERVAL_SECONDS: f64 = 1.0 / 120.0;
1501
1502#[derive(Debug, Clone)]
1503struct ActiveDrag {
1504 session_id: DragSessionId,
1505 scope_id: DragScopeId,
1506 pointer_id: u64,
1507 source: WidgetId,
1508 start_position: Point,
1509 position: Point,
1510 payload: DragPayload,
1511 allowed_effect: DropEffect,
1512 preview_label: Option<Arc<str>>,
1513 hover_path: Vec<WidgetId>,
1514 accepted_target: Option<WidgetId>,
1515 accepted_effect: DropEffect,
1516}
1517
1518impl ActiveDrag {
1519 fn from_request(request: BeginDragRequest) -> Self {
1520 Self {
1521 session_id: request.session_id,
1522 scope_id: request.scope_id,
1523 pointer_id: request.pointer_id,
1524 source: request.source,
1525 start_position: request.position,
1526 position: request.position,
1527 payload: request.payload,
1528 allowed_effect: request.allowed_effect,
1529 preview_label: request.preview_label.map(Arc::from),
1530 hover_path: Vec::new(),
1531 accepted_target: None,
1532 accepted_effect: DropEffect::None,
1533 }
1534 }
1535
1536 fn event(
1537 &self,
1538 kind: DragEventKind,
1539 position: Point,
1540 target: Option<WidgetId>,
1541 accepted_effect: DropEffect,
1542 outcome: Option<DragOutcome>,
1543 ) -> Event {
1544 Event::Drag(DragEvent {
1545 kind,
1546 session_id: self.session_id,
1547 scope_id: self.scope_id,
1548 pointer_id: self.pointer_id,
1549 source: self.source,
1550 target,
1551 position,
1552 start_position: self.start_position,
1553 payload: self.payload.clone(),
1554 allowed_effect: self.allowed_effect,
1555 accepted_effect,
1556 preview_label: self.preview_label.clone(),
1557 outcome,
1558 })
1559 }
1560}
1561
1562struct WindowState {
1563 id: WindowId,
1564 title: String,
1565 icon: Option<WindowIcon>,
1566 root: WidgetPod,
1567 graph: WidgetGraph,
1568 overlay_manager: overlay::OverlayManager,
1569 pending_overlay_focus: Option<FocusRequest>,
1570 focus: FocusState,
1571 focused_semantics: Option<WidgetId>,
1572 schedule: FrameSchedule,
1573 scale_factor: f32,
1574 raw_dpi: Option<f32>,
1575 safe_area: SafeAreaInsets,
1576 viewport_hint: Option<Size>,
1577 viewport: Option<Size>,
1578 last_frame: Option<SceneFrame>,
1579 last_paint_bounds_by_widget: HashMap<WidgetId, Rect>,
1580 last_semantics: Vec<SemanticsNode>,
1581 pending_invalidations: Vec<InvalidationRequest>,
1582 pending_reactive_diagnostics: Vec<ReactiveInvalidationSample>,
1583 reactive_hub: Arc<reactive::ReactiveInvalidationHub>,
1584 pointer_capture: HashMap<u64, WidgetId>,
1585 last_pointer_events: HashMap<u64, PointerEvent>,
1586 pointer_hover_paths: HashMap<u64, Vec<WidgetId>>,
1587 active_drag: Option<ActiveDrag>,
1588 scheduled_timers: Vec<ScheduledTimer>,
1589 delivering_timers: HashMap<TimerToken, WidgetId>,
1590 async_wake_targets: HashMap<AsyncWakeToken, WidgetId>,
1591 pending_async_wakeups: VecDeque<AsyncWakeToken>,
1592 requested_animation_frames: BTreeSet<WidgetId>,
1593 delivering_animation_frames: VecDeque<WidgetId>,
1594 last_animation_frame_time: Option<f64>,
1595 next_animation_frame_index: u64,
1596 pending_animation_wake_count: usize,
1597 ime_composition_rect: Option<Rect>,
1598 last_tick_time: f64,
1599 clipboard: Clipboard,
1600 command_sender: CommandSender,
1601 command_listeners: CommandListeners,
1602 pending_command_diagnostics: Vec<CommandDispatchSample>,
1603 pending_invalidation_diagnostics: Vec<InvalidationTraceSample>,
1604 inspector_tracing_enabled: bool,
1605 next_event_route_sequence: u64,
1606 event_route_history: VecDeque<EventRouteTraceSample>,
1607 reactive_invalidation_history: VecDeque<ReactiveInvalidationSample>,
1608 command_dispatch_history: VecDeque<CommandDispatchSample>,
1609 invalidation_history: VecDeque<InvalidationTraceSample>,
1610 widget_rebuild_history: VecDeque<WidgetRebuildSample>,
1611 last_render_diagnostics: RenderDiagnostics,
1612}
1613
1614impl WindowState {
1615 fn new(
1616 id: WindowId,
1617 title: String,
1618 icon: Option<WindowIcon>,
1619 root: WidgetPod,
1620 command_listeners: CommandListeners,
1621 command_sender: CommandSender,
1622 ) -> Self {
1623 let focus = FocusState {
1624 focused_widget: None,
1625 window_focused: true,
1626 };
1627
1628 let reactive_hub = reactive::ReactiveInvalidationHub::new();
1629 reactive::register_window(id, &reactive_hub);
1630 Self {
1631 id,
1632 title,
1633 icon,
1634 graph: WidgetGraph::empty(root.id()),
1635 overlay_manager: overlay::OverlayManager::default(),
1636 pending_overlay_focus: None,
1637 root,
1638 focus,
1639 focused_semantics: None,
1640 schedule: FrameSchedule::bootstrap(),
1641 scale_factor: 1.0,
1642 raw_dpi: None,
1643 safe_area: SafeAreaInsets::ZERO,
1644 viewport_hint: None,
1645 viewport: None,
1646 last_frame: None,
1647 last_paint_bounds_by_widget: HashMap::new(),
1648 last_semantics: Vec::new(),
1649 pending_invalidations: Vec::new(),
1650 pending_reactive_diagnostics: Vec::new(),
1651 reactive_hub,
1652 pointer_capture: HashMap::new(),
1653 last_pointer_events: HashMap::new(),
1654 pointer_hover_paths: HashMap::new(),
1655 active_drag: None,
1656 scheduled_timers: Vec::new(),
1657 delivering_timers: HashMap::new(),
1658 async_wake_targets: HashMap::new(),
1659 pending_async_wakeups: VecDeque::new(),
1660 requested_animation_frames: BTreeSet::new(),
1661 delivering_animation_frames: VecDeque::new(),
1662 last_animation_frame_time: None,
1663 next_animation_frame_index: 0,
1664 pending_animation_wake_count: 0,
1665 ime_composition_rect: None,
1666 last_tick_time: 0.0,
1667 clipboard: Clipboard::new(),
1668 command_sender,
1669 command_listeners,
1670 pending_command_diagnostics: Vec::new(),
1671 pending_invalidation_diagnostics: Vec::new(),
1672 inspector_tracing_enabled: false,
1673 next_event_route_sequence: 0,
1674 event_route_history: VecDeque::new(),
1675 reactive_invalidation_history: VecDeque::new(),
1676 command_dispatch_history: VecDeque::new(),
1677 invalidation_history: VecDeque::new(),
1678 widget_rebuild_history: VecDeque::new(),
1679 last_render_diagnostics: RenderDiagnostics::default(),
1680 }
1681 }
1682
1683 fn drain_reactive_invalidations(&mut self) {
1684 const MAX_REACTIVE_ROUNDS: usize = 8;
1685
1686 for _ in 0..MAX_REACTIVE_ROUNDS {
1687 let pending = self.reactive_hub.drain();
1688 if pending.is_empty() {
1689 break;
1690 }
1691
1692 let mut invalidations = Vec::new();
1693 let mut targets = BTreeSet::new();
1694 for (request, mut sample) in pending {
1695 let InvalidationTarget::Widget(widget_id) = request.target else {
1696 continue;
1697 };
1698 let delivered = self.graph.is_empty() || self.graph.contains(widget_id);
1699 sample.delivered = delivered;
1700 if delivered {
1701 push_trace(
1702 &mut self.pending_invalidation_diagnostics,
1703 InvalidationTraceSample {
1704 target: request.target,
1705 kind: request.kind,
1706 region: request.region,
1707 source: format!("reactive:{}", sample.source_name),
1708 reason: Some(format!("observable version {}", sample.version)),
1709 },
1710 );
1711 }
1712 self.pending_reactive_diagnostics.push(sample);
1713 if delivered {
1714 targets.insert(widget_id);
1715 invalidations.push(request);
1716 }
1717 }
1718
1719 for target in targets {
1720 let command = command::queued_command(
1721 CommandTarget::Widget {
1722 window_id: self.id,
1723 widget_id: target,
1724 },
1725 CommandDelivery::Directed,
1726 REACTIVE_CHANGED,
1727 (),
1728 );
1729 let Some(dispatch) = self.dispatch_direct_command(target, &command) else {
1730 continue;
1731 };
1732 let focus_request = dispatch.focus_request;
1733 let mut effects = EventEffects::default();
1734 effects.extend(dispatch);
1735 self.apply_event_effects(effects, &mut invalidations);
1736 if let Some(request) = focus_request {
1737 let focus_effects = self.apply_focus_request(request);
1738 self.apply_event_effects(focus_effects, &mut invalidations);
1739 }
1740 }
1741
1742 self.schedule.extend(&invalidations);
1743 self.pending_invalidations.extend(invalidations);
1744 }
1745 }
1746
1747 fn needs_render(&self) -> bool {
1748 self.last_frame.is_none() || self.schedule.needs_render() || self.reactive_hub.has_pending()
1749 }
1750
1751 fn handle_event(
1752 &mut self,
1753 event: Event,
1754 text_system: Arc<TextSystem>,
1755 font_registry: Arc<FontRegistry>,
1756 image_registry: Arc<ImageRegistry>,
1757 ) -> bool {
1758 if matches!(event, Event::Window(WindowEvent::RedrawRequested)) {
1759 diagnostics::begin_widget_timing_collection();
1760 sui_text::begin_text_timing_collection();
1761 }
1762 if matches!(event, Event::Wake(WakeEvent::AnimationFrame { .. })) {
1763 self.pending_animation_wake_count = self.pending_animation_wake_count.saturating_add(1);
1764 }
1765 if let Event::Pointer(pointer) = &event {
1766 self.last_pointer_events
1767 .insert(pointer.pointer_id, pointer.clone());
1768 }
1769
1770 self.preprocess_window_event(&event);
1771 self.ensure_graph_for_event(&event, text_system, font_registry, image_registry);
1772
1773 let mut invalidations = Vec::new();
1774 self.apply_pending_overlay_focus(&mut invalidations);
1775
1776 let captured_target = match &event {
1777 Event::Pointer(pointer) => self.pointer_capture.get(&pointer.pointer_id).copied(),
1778 _ => None,
1779 };
1780
1781 let pointer_hit_target = match &event {
1782 Event::Pointer(pointer) => self.pointer_hit_target(pointer.position),
1783 _ => None,
1784 };
1785 let mut hit_target = match &event {
1786 Event::Pointer(_) if captured_target.is_some() => None,
1787 Event::Pointer(_) => pointer_hit_target,
1788 _ => None,
1789 };
1790
1791 if matches!(event, Event::Window(WindowEvent::Focused(false))) {
1792 self.cancel_all_pointer_captures(&mut invalidations);
1793 self.pointer_capture.clear();
1794 self.last_pointer_events.clear();
1795 self.active_drag = None;
1796 }
1797 let mut skip_primary_route = false;
1798 if let Event::Pointer(pointer) = &event {
1799 let hover_route = self.update_pointer_hover_path(pointer, hit_target);
1800 self.apply_event_effects(hover_route.effects, &mut invalidations);
1801
1802 if let Some(request) = hover_route.focus_request {
1803 let focus_effects = self.apply_focus_request(request);
1804 self.apply_event_effects(focus_effects, &mut invalidations);
1805 }
1806
1807 skip_primary_route = hover_route.skip_primary_route;
1808 }
1809
1810 if skip_primary_route {
1811 self.finish_event(&event);
1812 self.record_event_invalidations(&invalidations, &event);
1813 self.schedule.extend(&invalidations);
1814 self.pending_invalidations.extend(invalidations);
1815 return false;
1816 }
1817
1818 if matches!(
1819 &event,
1820 Event::Keyboard(key)
1821 if key.state == KeyState::Pressed
1822 && key.key == "BrowserBack"
1823 && !key.repeat
1824 && !key.is_composing
1825 ) && self.ime_composition_rect.is_some()
1826 && self.focus.focused_widget.is_some()
1827 {
1828 self.ime_composition_rect = None;
1833 let effects = self.apply_focus_request_unconstrained(FocusRequest::Clear);
1834 self.apply_event_effects(effects, &mut invalidations);
1835 self.finish_event(&event);
1836 self.record_event_invalidations(&invalidations, &event);
1837 self.schedule.extend(&invalidations);
1838 self.pending_invalidations.extend(invalidations);
1839 return true;
1840 }
1841
1842 if matches!(
1843 &event,
1844 Event::Keyboard(key)
1845 if key.state == KeyState::Pressed
1846 && matches!(key.key.as_str(), "Escape" | "BrowserBack")
1847 && !key.repeat
1848 && !key.is_composing
1849 ) && self.dispatch_overlay_dismissal(
1850 OverlayDismissReason::Escape,
1851 None,
1852 &mut invalidations,
1853 ) {
1854 self.finish_event(&event);
1855 self.record_event_invalidations(&invalidations, &event);
1856 self.schedule.extend(&invalidations);
1857 self.pending_invalidations.extend(invalidations);
1858 return true;
1859 }
1860
1861 if let Event::Pointer(pointer) = &event
1862 && pointer.kind == PointerEventKind::Down
1863 && pointer.button == Some(PointerButton::Primary)
1864 && let Some(entry) = self
1865 .overlay_manager
1866 .topmost_dismissible(OverlayDismissReason::OutsidePointer)
1867 .cloned()
1868 && !hit_target.is_some_and(|target| self.target_is_in_overlay(entry.owner, target))
1869 {
1870 self.dispatch_overlay_dismissal(
1871 OverlayDismissReason::OutsidePointer,
1872 Some(pointer.position),
1873 &mut invalidations,
1874 );
1875 }
1876
1877 if let Some(modal) = self.overlay_manager.active_modal()
1878 && hit_target.is_some_and(|target| !self.target_is_in_overlay(modal, target))
1879 {
1880 hit_target = Some(modal);
1881 }
1882
1883 let target = self.resolve_event_target(&event, hit_target);
1884
1885 let route = self.route_event(target, &event);
1886 let handled = route.handled;
1887
1888 let focus_request = route
1889 .focus_request
1890 .or_else(|| self.default_focus_request(&event, hit_target, &route.path));
1891 self.apply_event_effects(route.effects, &mut invalidations);
1892
1893 if let Some(request) = focus_request {
1894 let focus_effects = self.apply_focus_request(request);
1895 self.apply_event_effects(focus_effects, &mut invalidations);
1896 }
1897
1898 if let Event::Pointer(pointer) = &event {
1899 let drag_effects = self.handle_drag_pointer_event(pointer, pointer_hit_target);
1900 self.apply_event_effects(drag_effects, &mut invalidations);
1901 }
1902
1903 self.finish_event(&event);
1904 self.record_event_invalidations(&invalidations, &event);
1905 self.schedule.extend(&invalidations);
1906 self.pending_invalidations.extend(invalidations);
1907 handled
1908 }
1909
1910 fn record_event_invalidations(&mut self, invalidations: &[InvalidationRequest], event: &Event) {
1911 let source = event_trace_source(event);
1912 extend_traces(
1913 &mut self.pending_invalidation_diagnostics,
1914 invalidations.iter().map(|request| InvalidationTraceSample {
1915 target: request.target,
1916 kind: request.kind,
1917 region: request.region,
1918 source: source.clone(),
1919 reason: None,
1920 }),
1921 );
1922 }
1923
1924 fn target_is_in_overlay(&self, owner: WidgetId, target: WidgetId) -> bool {
1925 target == owner || self.graph.is_ancestor_of(owner, target)
1926 }
1927
1928 fn dispatch_overlay_dismissal(
1929 &mut self,
1930 reason: OverlayDismissReason,
1931 pointer_position: Option<Point>,
1932 invalidations: &mut Vec<InvalidationRequest>,
1933 ) -> bool {
1934 let Some(entry) = self.overlay_manager.topmost_dismissible(reason).cloned() else {
1935 return false;
1936 };
1937 let mut request = OverlayDismissRequest::new(reason);
1938 request.pointer_position = pointer_position;
1939 let queued = command::queued_command(
1940 CommandTarget::Widget {
1941 window_id: self.id,
1942 widget_id: entry.owner,
1943 },
1944 CommandDelivery::Directed,
1945 OVERLAY_DISMISS_REQUEST,
1946 request,
1947 );
1948 let Some(dispatch) = self.dispatch_direct_command(entry.owner, &queued) else {
1949 return false;
1950 };
1951 let handled = dispatch.handled;
1952 let focus_request = dispatch.focus_request;
1953 let mut effects = EventEffects::default();
1954 effects.extend(dispatch);
1955 self.apply_event_effects(effects, invalidations);
1956 if let Some(request) = focus_request {
1957 let effects = self.apply_focus_request(request);
1958 self.apply_event_effects(effects, invalidations);
1959 }
1960 if handled {
1961 self.overlay_manager
1962 .trace_dismissal(entry.owner, entry.options.kind, reason);
1963 }
1964 handled
1965 }
1966
1967 fn handle_semantics_action(
1968 &mut self,
1969 target: WidgetId,
1970 action: SemanticsActionRequest,
1971 text_system: Arc<TextSystem>,
1972 font_registry: Arc<FontRegistry>,
1973 image_registry: Arc<ImageRegistry>,
1974 ) -> bool {
1975 let Some(node) = self
1976 .last_semantics
1977 .iter()
1978 .find(|node| node.id == target)
1979 .cloned()
1980 else {
1981 return false;
1982 };
1983
1984 if node.state.hidden
1985 || node.state.disabled
1986 || !node.actions.contains(&action.advertised_action())
1987 {
1988 return false;
1989 }
1990
1991 if matches!(
1992 (&action, node.state.expanded),
1993 (SemanticsActionRequest::Expand, Some(true))
1994 | (SemanticsActionRequest::Collapse, Some(false))
1995 ) {
1996 return true;
1997 }
1998
1999 let event = Event::Semantics(SemanticsEvent::new(target, action.clone()));
2000 self.ensure_graph_for_event(
2001 &event,
2002 Arc::clone(&text_system),
2003 Arc::clone(&font_registry),
2004 Arc::clone(&image_registry),
2005 );
2006
2007 let route_target = self.semantics_route_target(target);
2008 let route = self.route_event(route_target, &event);
2009 let handled = route.handled;
2010 let semantics_was_focused = self.focused_semantics == Some(target);
2011 let mut focus_request = route.focus_request;
2012 let widget_requested_focus = matches!(focus_request, Some(FocusRequest::Focus(_)));
2013 let mut focus_succeeded = false;
2014 let mut invalidations = Vec::new();
2015 self.apply_event_effects(route.effects, &mut invalidations);
2016
2017 match action {
2018 SemanticsActionRequest::Focus => {
2019 let runtime_focus_request = focus_request
2020 .is_none()
2021 .then(|| self.focus_request_for(route_target))
2022 .flatten();
2023 focus_succeeded =
2024 handled || widget_requested_focus || runtime_focus_request.is_some();
2025 focus_request = focus_request.or(runtime_focus_request);
2026 }
2027 SemanticsActionRequest::Blur if semantics_was_focused => {
2028 focus_request = Some(FocusRequest::Clear);
2029 }
2030 _ => {}
2031 }
2032
2033 if let Some(request) = focus_request {
2034 let focus_effects = self.apply_focus_request(request);
2035 self.apply_event_effects(focus_effects, &mut invalidations);
2036 }
2037
2038 match action {
2039 SemanticsActionRequest::Focus if focus_succeeded => {
2040 self.focused_semantics = Some(target);
2041 self.schedule.mark(InvalidationKind::Semantics);
2042 }
2043 SemanticsActionRequest::Blur if semantics_was_focused => {
2044 self.focused_semantics = None;
2045 self.schedule.mark(InvalidationKind::Semantics);
2046 }
2047 _ => {}
2048 }
2049
2050 self.schedule.extend(&invalidations);
2051 self.pending_invalidations.extend(invalidations);
2052
2053 let pointer_fallback = matches!(
2054 action,
2055 SemanticsActionRequest::Activate
2056 | SemanticsActionRequest::Expand
2057 | SemanticsActionRequest::Collapse
2058 );
2059 if pointer_fallback && !handled && !node.bounds.is_empty() {
2060 self.dispatch_semantics_pointer_activation(
2061 node.bounds,
2062 text_system,
2063 font_registry,
2064 image_registry,
2065 );
2066 return true;
2067 }
2068
2069 handled
2070 || matches!(action, SemanticsActionRequest::Focus) && focus_succeeded
2071 || matches!(action, SemanticsActionRequest::Blur) && semantics_was_focused
2072 }
2073
2074 fn semantics_route_target(&self, target: WidgetId) -> WidgetId {
2075 let mut current = Some(target);
2076 let mut visited = HashSet::new();
2077
2078 while let Some(candidate) = current {
2079 if !visited.insert(candidate) {
2080 break;
2081 }
2082 if self.graph.contains(candidate) {
2083 return candidate;
2084 }
2085 current = self
2086 .last_semantics
2087 .iter()
2088 .find(|node| node.id == candidate)
2089 .and_then(|node| node.parent);
2090 }
2091
2092 self.root.id()
2093 }
2094
2095 fn focus_request_for(&self, target: WidgetId) -> Option<FocusRequest> {
2096 self.graph.path_to(target).and_then(|path| {
2097 path.into_iter()
2098 .rev()
2099 .find(|widget_id| {
2100 self.graph
2101 .node(*widget_id)
2102 .is_some_and(|node| node.accepts_focus)
2103 })
2104 .map(FocusRequest::Focus)
2105 })
2106 }
2107
2108 fn dispatch_semantics_pointer_activation(
2109 &mut self,
2110 bounds: Rect,
2111 text_system: Arc<TextSystem>,
2112 font_registry: Arc<FontRegistry>,
2113 image_registry: Arc<ImageRegistry>,
2114 ) {
2115 let position = Point::new(
2116 bounds.x() + bounds.width() * 0.5,
2117 bounds.y() + bounds.height() * 0.5,
2118 );
2119
2120 let mut down = PointerEvent::new(PointerEventKind::Down, position);
2121 down.button = Some(PointerButton::Primary);
2122 down.buttons.insert(PointerButton::Primary);
2123 self.handle_event(
2124 Event::Pointer(down),
2125 Arc::clone(&text_system),
2126 Arc::clone(&font_registry),
2127 Arc::clone(&image_registry),
2128 );
2129
2130 let mut up = PointerEvent::new(PointerEventKind::Up, position);
2131 up.button = Some(PointerButton::Primary);
2132 self.handle_event(
2133 Event::Pointer(up),
2134 text_system,
2135 font_registry,
2136 image_registry,
2137 );
2138 }
2139
2140 fn update_pointer_hover_path(
2141 &mut self,
2142 pointer: &PointerEvent,
2143 hit_target: Option<WidgetId>,
2144 ) -> HoverTransitionResult {
2145 let skip_primary_route = matches!(
2146 pointer.kind,
2147 PointerEventKind::Enter | PointerEventKind::Leave
2148 );
2149
2150 let next_path = match pointer.kind {
2151 PointerEventKind::Move | PointerEventKind::Enter
2152 if pointer.buttons.is_empty()
2153 && !self.pointer_capture.contains_key(&pointer.pointer_id) =>
2154 {
2155 self.hover_transition_path(hit_target)
2156 }
2157 PointerEventKind::Leave | PointerEventKind::Cancel => Vec::new(),
2158 _ => {
2159 return HoverTransitionResult {
2160 skip_primary_route,
2161 ..HoverTransitionResult::default()
2162 };
2163 }
2164 };
2165
2166 let previous_path = self
2167 .pointer_hover_paths
2168 .remove(&pointer.pointer_id)
2169 .unwrap_or_default();
2170 if previous_path == next_path {
2171 if !next_path.is_empty() {
2172 self.pointer_hover_paths
2173 .insert(pointer.pointer_id, next_path);
2174 }
2175 return HoverTransitionResult {
2176 skip_primary_route,
2177 ..HoverTransitionResult::default()
2178 };
2179 }
2180
2181 let shared_prefix_len = previous_path
2182 .iter()
2183 .zip(next_path.iter())
2184 .take_while(|(left, right)| left == right)
2185 .count();
2186
2187 let mut result = HoverTransitionResult {
2188 skip_primary_route,
2189 ..HoverTransitionResult::default()
2190 };
2191
2192 let mut leave_pointer = pointer.clone();
2193 leave_pointer.kind = PointerEventKind::Leave;
2194 let leave_event = Event::Pointer(leave_pointer);
2195 for widget_id in previous_path[shared_prefix_len..].iter().rev().copied() {
2196 let dispatch = self.dispatch_direct_event(widget_id, &leave_event);
2197 let dispatch_focus_request = dispatch.focus_request;
2198 result.effects.extend(dispatch);
2199 if dispatch_focus_request.is_some() {
2200 result.focus_request = dispatch_focus_request;
2201 }
2202 }
2203
2204 let mut enter_pointer = pointer.clone();
2205 enter_pointer.kind = PointerEventKind::Enter;
2206 let enter_event = Event::Pointer(enter_pointer);
2207 for widget_id in next_path[shared_prefix_len..].iter().copied() {
2208 let dispatch = self.dispatch_direct_event(widget_id, &enter_event);
2209 let dispatch_focus_request = dispatch.focus_request;
2210 result.effects.extend(dispatch);
2211 if dispatch_focus_request.is_some() {
2212 result.focus_request = dispatch_focus_request;
2213 }
2214 }
2215
2216 if !next_path.is_empty() {
2217 self.pointer_hover_paths
2218 .insert(pointer.pointer_id, next_path);
2219 }
2220
2221 result
2222 }
2223
2224 fn hover_transition_path(&self, hit_target: Option<WidgetId>) -> Vec<WidgetId> {
2225 hit_target
2226 .and_then(|target| self.graph.path_to(target))
2227 .map(|path| path.into_iter().skip(1).collect())
2228 .unwrap_or_default()
2229 }
2230
2231 fn dispatch_direct_event(&mut self, target: WidgetId, event: &Event) -> widget::EventDispatch {
2232 let path = self.graph.path_to(target);
2233 let dpi_info = self.current_dpi_info();
2234 self.root
2235 .dispatch_event_for_path(
2236 path.as_deref().unwrap_or(&[self.root.id()]),
2237 self.id,
2238 dpi_info,
2239 self.last_tick_time,
2240 EventPhase::Target,
2241 self.focus.focused_widget,
2242 &self.clipboard,
2243 &self.command_sender,
2244 event,
2245 )
2246 .or_else(|| {
2247 self.root.dispatch_event_for(
2248 target,
2249 self.id,
2250 dpi_info,
2251 self.last_tick_time,
2252 EventPhase::Target,
2253 self.focus.focused_widget,
2254 &self.clipboard,
2255 &self.command_sender,
2256 event,
2257 )
2258 })
2259 .unwrap_or_else(empty_dispatch)
2260 }
2261
2262 fn dispatch_direct_command(
2263 &mut self,
2264 target: WidgetId,
2265 command: &QueuedCommand,
2266 ) -> Option<widget::EventDispatch> {
2267 let path = if target == self.root.id() {
2268 vec![target]
2269 } else {
2270 self.graph.path_to(target)?
2271 };
2272 let dpi_info = self.current_dpi_info();
2273 let command = Command::new(command);
2274 self.root
2275 .dispatch_command_for_path(
2276 &path,
2277 self.id,
2278 dpi_info,
2279 self.last_tick_time,
2280 self.focus.focused_widget,
2281 &self.clipboard,
2282 &self.command_sender,
2283 &command,
2284 )
2285 .or_else(|| {
2286 self.root.dispatch_command_for(
2287 target,
2288 self.id,
2289 dpi_info,
2290 self.last_tick_time,
2291 self.focus.focused_widget,
2292 &self.clipboard,
2293 &self.command_sender,
2294 &command,
2295 )
2296 })
2297 }
2298
2299 fn record_command_invalidations(
2300 &mut self,
2301 invalidations: &[InvalidationRequest],
2302 source: &str,
2303 reason: Option<&str>,
2304 ) {
2305 extend_traces(
2306 &mut self.pending_invalidation_diagnostics,
2307 invalidations.iter().map(|request| InvalidationTraceSample {
2308 target: request.target,
2309 kind: request.kind,
2310 region: request.region,
2311 source: format!("command:{source}"),
2312 reason: reason.map(str::to_string),
2313 }),
2314 );
2315 }
2316
2317 fn pointer_hit_target(&mut self, point: Point) -> Option<WidgetId> {
2318 let floating_hit = self.floating_layer_hit_test(point);
2319 let focused_floating_hit = if floating_hit.is_none() {
2320 self.focused_floating_layer_hit_test(point)
2321 } else {
2322 None
2323 };
2324 floating_hit
2325 .or(focused_floating_hit)
2326 .or_else(|| self.graph.hit_test(point))
2327 }
2328
2329 fn floating_layer_hit_test(&mut self, point: Point) -> Option<WidgetId> {
2330 let effect_hit = {
2331 let scene = self.last_frame.as_ref().map(|frame| &frame.scene)?;
2332 scene_hit_test_for_phase(
2333 scene,
2334 point,
2335 HitTestCompositionPhase::Effect,
2336 HitTestCompositionPhase::Normal,
2337 )
2338 };
2339 if let Some(widget_id) = effect_hit
2340 && self
2341 .current_widget_matches_hit_test_phase(widget_id, HitTestCompositionPhase::Effect)
2342 {
2343 return self
2344 .graph
2345 .hit_test_within(widget_id, point)
2346 .or(Some(widget_id));
2347 }
2348
2349 let overlay_hit = {
2350 let scene = self.last_frame.as_ref().map(|frame| &frame.scene)?;
2351 scene_hit_test_for_phase(
2352 scene,
2353 point,
2354 HitTestCompositionPhase::Overlay,
2355 HitTestCompositionPhase::Normal,
2356 )
2357 };
2358 overlay_hit.and_then(|widget_id| {
2359 self.current_widget_matches_hit_test_phase(widget_id, HitTestCompositionPhase::Overlay)
2360 .then(|| {
2361 self.graph
2362 .hit_test_within(widget_id, point)
2363 .unwrap_or(widget_id)
2364 })
2365 })
2366 }
2367
2368 fn focused_floating_layer_hit_test(&mut self, point: Point) -> Option<WidgetId> {
2369 let focused = self.focus.focused_widget?;
2370 if !self.current_widget_matches_hit_test_phase(focused, HitTestCompositionPhase::Overlay)
2371 && !self.current_widget_matches_hit_test_phase(focused, HitTestCompositionPhase::Effect)
2372 {
2373 return None;
2374 }
2375
2376 let scene = self.last_frame.as_ref().map(|frame| &frame.scene)?;
2377 let descriptor = collect_scene_layers(scene).get(&focused)?.clone();
2378 (descriptor.hit_test && descriptor.paint_bounds.contains(point)).then_some(focused)
2379 }
2380
2381 fn current_widget_matches_hit_test_phase(
2382 &mut self,
2383 widget_id: WidgetId,
2384 target_phase: HitTestCompositionPhase,
2385 ) -> bool {
2386 if !self.graph.node(widget_id).is_some_and(|node| node.hit_test) {
2387 return false;
2388 }
2389 let Some(composition_mode) = self.current_widget_composition_mode(widget_id) else {
2390 return false;
2391 };
2392
2393 next_hit_test_phase(HitTestCompositionPhase::Normal, composition_mode) == target_phase
2394 }
2395
2396 fn current_widget_composition_mode(
2397 &mut self,
2398 widget_id: WidgetId,
2399 ) -> Option<LayerCompositionMode> {
2400 self.root.layer_composition_mode_for(widget_id)
2401 }
2402
2403 fn animation_frame_deadline(&self) -> Option<f64> {
2404 (!self.requested_animation_frames.is_empty()).then_some(
2405 self.last_animation_frame_time
2406 .map_or(self.last_tick_time, |last| {
2407 last + ANIMATION_FRAME_INTERVAL_SECONDS
2408 }),
2409 )
2410 }
2411
2412 fn next_wakeup_time(&self) -> Option<f64> {
2413 let mut next = self
2414 .scheduled_timers
2415 .iter()
2416 .map(|timer| timer.deadline)
2417 .min_by(|left, right| left.total_cmp(right));
2418
2419 if !self.pending_async_wakeups.is_empty() {
2420 next = Some(next.map_or(self.last_tick_time, |deadline| {
2421 deadline.min(self.last_tick_time)
2422 }));
2423 }
2424
2425 if let Some(animation_deadline) = self.animation_frame_deadline() {
2426 next = Some(next.map_or(animation_deadline, |deadline| {
2427 deadline.min(animation_deadline)
2428 }));
2429 }
2430
2431 next
2432 }
2433
2434 fn active_animated_widget_count(&self) -> usize {
2435 self.requested_animation_frames
2436 .iter()
2437 .copied()
2438 .chain(self.delivering_animation_frames.iter().copied())
2439 .collect::<BTreeSet<_>>()
2440 .len()
2441 }
2442
2443 fn animation_frame_is_transform_only(
2444 &self,
2445 repainted: bool,
2446 layer_updates: &[SceneLayerUpdate],
2447 ) -> bool {
2448 !repainted
2449 && !layer_updates.is_empty()
2450 && layer_updates.iter().all(|update| {
2451 matches!(
2452 update.kind,
2453 SceneLayerUpdateKind::Transform
2454 | SceneLayerUpdateKind::Effect
2455 | SceneLayerUpdateKind::Visibility
2456 )
2457 })
2458 }
2459
2460 fn drain_ready_events(&mut self) -> Vec<Event> {
2461 let now = self.last_tick_time;
2462 let mut ready = Vec::new();
2463 let mut pending_timers = Vec::with_capacity(self.scheduled_timers.len());
2464
2465 for timer in self.scheduled_timers.drain(..) {
2466 if timer.deadline <= now {
2467 self.delivering_timers.insert(timer.token, timer.target);
2468 ready.push(Event::Wake(WakeEvent::Timer {
2469 token: timer.token,
2470 time: now,
2471 deadline: timer.deadline,
2472 }));
2473 } else {
2474 pending_timers.push(timer);
2475 }
2476 }
2477 self.scheduled_timers = pending_timers;
2478
2479 while let Some(token) = self.pending_async_wakeups.pop_front() {
2480 if self.async_wake_targets.contains_key(&token) {
2481 ready.push(Event::Wake(WakeEvent::Async { token, time: now }));
2482 }
2483 }
2484
2485 if self
2486 .animation_frame_deadline()
2487 .is_some_and(|deadline| deadline <= now)
2488 {
2489 let delta = self
2490 .last_animation_frame_time
2491 .map(|last| (now - last).max(0.0))
2492 .unwrap_or(0.0);
2493 let frame_index = self.next_animation_frame_index;
2494 self.next_animation_frame_index = self.next_animation_frame_index.saturating_add(1);
2495
2496 let requested = std::mem::take(&mut self.requested_animation_frames);
2497 self.delivering_animation_frames
2498 .extend(requested.iter().copied());
2499 ready.extend(requested.iter().map(|_| {
2500 Event::Wake(WakeEvent::AnimationFrame {
2501 time: now,
2502 delta,
2503 frame_index,
2504 })
2505 }));
2506 self.last_animation_frame_time = Some(now);
2507 } else if self.delivering_animation_frames.is_empty()
2508 && self.requested_animation_frames.is_empty()
2509 {
2510 self.last_animation_frame_time = None;
2511 }
2512
2513 ready
2514 }
2515
2516 fn wake_async(&mut self, token: AsyncWakeToken) -> bool {
2517 if !self.async_wake_targets.contains_key(&token) {
2518 return false;
2519 }
2520
2521 self.pending_async_wakeups.push_back(token);
2522 true
2523 }
2524
2525 fn invalidate_layout_for_viewport_change(&mut self) {
2532 self.schedule.mark(InvalidationKind::Measure);
2533 self.pending_invalidations.push(InvalidationRequest::new(
2534 InvalidationTarget::Window(self.id),
2535 InvalidationKind::Measure,
2536 ));
2537 }
2538
2539 fn preprocess_window_event(&mut self, event: &Event) {
2540 let Event::Window(window_event) = event else {
2541 return;
2542 };
2543
2544 match window_event {
2545 WindowEvent::Resized(size) => {
2546 self.viewport_hint = Some(*size);
2547 self.invalidate_layout_for_viewport_change();
2548 }
2549 WindowEvent::ScaleFactorChanged {
2550 scale_factor,
2551 raw_dpi,
2552 suggested_size,
2553 } => {
2554 self.scale_factor = *scale_factor as f32;
2555 self.raw_dpi = *raw_dpi;
2556 if let Some(size) = suggested_size {
2557 self.viewport_hint = Some(*size);
2558 }
2559 self.invalidate_layout_for_viewport_change();
2560 }
2561 WindowEvent::SafeAreaChanged(safe_area) => {
2562 let safe_area = safe_area.normalized();
2563 if self.safe_area != safe_area {
2564 self.safe_area = safe_area;
2565 self.invalidate_layout_for_viewport_change();
2566 }
2567 }
2568 WindowEvent::Focused(focused) => {
2569 self.focus.window_focused = *focused;
2570 }
2571 WindowEvent::RedrawRequested => {
2572 self.schedule.mark(InvalidationKind::Paint);
2573 }
2574 WindowEvent::CloseRequested
2575 | WindowEvent::Occluded(_)
2576 | WindowEvent::ExternalFileHovered(_)
2577 | WindowEvent::ExternalFileHoverCancelled
2578 | WindowEvent::ExternalFileDropped(_) => {}
2579 }
2580 }
2581
2582 fn ensure_graph_for_event(
2583 &mut self,
2584 event: &Event,
2585 text_system: Arc<TextSystem>,
2586 font_registry: Arc<FontRegistry>,
2587 image_registry: Arc<ImageRegistry>,
2588 ) {
2589 if self.schedule.measure || self.schedule.arrange || self.viewport.is_none() {
2590 let scope_source = self.pending_invalidations.clone();
2591 let invalidations = self.run_measure_arrange_pass(
2592 &scope_source,
2593 text_system,
2594 font_registry,
2595 image_registry,
2596 );
2597 self.schedule.extend(&invalidations);
2598 self.pending_invalidations.extend(invalidations);
2599 return;
2600 }
2601
2602 if self.schedule.hit_test || self.graph.is_empty() {
2603 self.refresh_graph();
2604 }
2605
2606 if matches!(event, Event::Keyboard(_) | Event::Ime(_))
2607 && self.focus.focused_widget.is_some()
2608 && !self
2609 .graph
2610 .contains(self.focus.focused_widget.unwrap_or_default())
2611 {
2612 self.focus.focused_widget = None;
2613 self.focused_semantics = None;
2614 }
2615 }
2616
2617 fn resolve_event_target(&self, event: &Event, hit_target: Option<WidgetId>) -> WidgetId {
2618 match event {
2619 Event::Pointer(pointer) => self
2620 .pointer_capture
2621 .get(&pointer.pointer_id)
2622 .copied()
2623 .or(hit_target)
2624 .unwrap_or(self.root.id()),
2625 Event::Keyboard(_) | Event::Ime(_) => {
2626 self.focus.focused_widget.unwrap_or(self.root.id())
2627 }
2628 Event::Semantics(semantics) => self.semantics_route_target(semantics.target),
2629 Event::Wake(wake_event) => self.wake_target(*wake_event).unwrap_or(self.root.id()),
2630 _ => self.root.id(),
2631 }
2632 }
2633
2634 fn wake_target(&self, wake_event: WakeEvent) -> Option<WidgetId> {
2635 match wake_event {
2636 WakeEvent::Timer { token, .. } => self.delivering_timers.get(&token).copied(),
2637 WakeEvent::Async { token, .. } => self.async_wake_targets.get(&token).copied(),
2638 WakeEvent::AnimationFrame { .. } => self.delivering_animation_frames.front().copied(),
2639 }
2640 }
2641
2642 fn apply_event_effects(
2643 &mut self,
2644 effects: EventEffects,
2645 invalidations: &mut Vec<InvalidationRequest>,
2646 ) {
2647 invalidations.extend(effects.invalidations);
2648 self.apply_wake_requests(effects.wake_requests);
2649 self.apply_pointer_capture_requests(effects.pointer_capture_requests, invalidations);
2650 self.apply_drag_requests(effects.drag_requests, invalidations);
2651 self.apply_posted_events(effects.posted_events, invalidations);
2652 self.apply_posted_commands(effects.posted_commands, invalidations);
2653 }
2654
2655 fn apply_posted_events(
2659 &mut self,
2660 mut posted: Vec<widget::PostedEventRequest>,
2661 invalidations: &mut Vec<InvalidationRequest>,
2662 ) {
2663 const MAX_POSTED_EVENT_ROUNDS: usize = 8;
2664
2665 let mut rounds = 0;
2666 while !posted.is_empty() && rounds < MAX_POSTED_EVENT_ROUNDS {
2667 rounds += 1;
2668 for request in std::mem::take(&mut posted) {
2669 let dispatch = self.dispatch_direct_event(request.target, &request.event);
2670 invalidations.extend(dispatch.invalidations);
2671 self.apply_wake_requests(dispatch.wake_requests);
2672 self.apply_pointer_capture_requests(
2673 dispatch.pointer_capture_requests,
2674 invalidations,
2675 );
2676 self.apply_drag_requests(dispatch.drag_requests, invalidations);
2677 posted.extend(dispatch.posted_events);
2678 self.apply_posted_commands(dispatch.posted_commands, invalidations);
2679 if let Some(request) = dispatch.focus_request {
2680 let focus_effects = self.apply_focus_request(request);
2681 invalidations.extend(focus_effects.invalidations);
2682 self.apply_wake_requests(focus_effects.wake_requests);
2683 self.apply_pointer_capture_requests(
2684 focus_effects.pointer_capture_requests,
2685 invalidations,
2686 );
2687 self.apply_drag_requests(focus_effects.drag_requests, invalidations);
2688 posted.extend(focus_effects.posted_events);
2689 self.apply_posted_commands(focus_effects.posted_commands, invalidations);
2690 }
2691 }
2692 }
2693 }
2694
2695 fn apply_posted_commands(
2696 &mut self,
2697 mut posted: Vec<widget::PostedCommandRequest>,
2698 invalidations: &mut Vec<InvalidationRequest>,
2699 ) {
2700 const MAX_POSTED_COMMAND_ROUNDS: usize = 8;
2701 let mut rounds = 0;
2702 while !posted.is_empty() && rounds < MAX_POSTED_COMMAND_ROUNDS {
2703 rounds += 1;
2704 for request in std::mem::take(&mut posted) {
2705 let CommandTarget::Widget { widget_id, .. } = request.command.target else {
2706 continue;
2707 };
2708 let Some(dispatch) = self.dispatch_direct_command(widget_id, &request.command)
2709 else {
2710 push_trace(
2711 &mut self.pending_command_diagnostics,
2712 command_sample(&request.command, Vec::new(), false, false),
2713 );
2714 continue;
2715 };
2716 self.record_command_invalidations(
2717 &dispatch.invalidations,
2718 request.command.key.name,
2719 Some("posted by widget"),
2720 );
2721 invalidations.extend(dispatch.invalidations);
2722 self.apply_wake_requests(dispatch.wake_requests);
2723 self.apply_pointer_capture_requests(
2724 dispatch.pointer_capture_requests,
2725 invalidations,
2726 );
2727 self.apply_drag_requests(dispatch.drag_requests, invalidations);
2728 self.apply_posted_events(dispatch.posted_events, invalidations);
2729 posted.extend(dispatch.posted_commands);
2730 push_trace(
2731 &mut self.pending_command_diagnostics,
2732 command_sample(
2733 &request.command,
2734 vec!["widget target".to_string()],
2735 dispatch.handled,
2736 true,
2737 ),
2738 );
2739 if let Some(focus_request) = dispatch.focus_request {
2740 let effects = self.apply_focus_request(focus_request);
2741 self.apply_event_effects(effects, invalidations);
2742 }
2743 }
2744 }
2745 }
2746
2747 fn apply_drag_requests(
2748 &mut self,
2749 requests: Vec<DragRequest>,
2750 invalidations: &mut Vec<InvalidationRequest>,
2751 ) {
2752 for request in requests {
2753 match request {
2754 DragRequest::Begin(request) => {
2755 self.active_drag = Some(ActiveDrag::from_request(request));
2756 invalidations.push(InvalidationRequest::new(
2757 InvalidationTarget::Window(self.id),
2758 InvalidationKind::Paint,
2759 ));
2760 }
2761 }
2762 }
2763 }
2764
2765 fn handle_drag_pointer_event(
2766 &mut self,
2767 pointer: &PointerEvent,
2768 hit_target: Option<WidgetId>,
2769 ) -> EventEffects {
2770 if self
2771 .active_drag
2772 .as_ref()
2773 .is_none_or(|drag| drag.pointer_id != pointer.pointer_id)
2774 {
2775 return EventEffects::default();
2776 }
2777
2778 match pointer.kind {
2779 PointerEventKind::Move => self.update_active_drag(pointer.position, hit_target),
2780 PointerEventKind::Up => {
2781 let mut effects = self.update_active_drag(pointer.position, hit_target);
2782 effects.merge(self.finish_active_drag(pointer.position, false));
2783 effects
2784 }
2785 PointerEventKind::Cancel | PointerEventKind::Leave => {
2786 self.finish_active_drag(pointer.position, true)
2787 }
2788 _ => EventEffects::default(),
2789 }
2790 }
2791
2792 fn update_active_drag(
2793 &mut self,
2794 position: Point,
2795 hit_target: Option<WidgetId>,
2796 ) -> EventEffects {
2797 let Some((previous_path, active_snapshot)) = self.active_drag.as_mut().map(|active| {
2798 active.position = position;
2799 (active.hover_path.clone(), active.clone())
2800 }) else {
2801 return EventEffects::default();
2802 };
2803
2804 let next_path = hit_target
2805 .and_then(|target| self.graph.path_to(target))
2806 .unwrap_or_default();
2807
2808 let mut effects = EventEffects::default();
2809 effects.invalidations.push(InvalidationRequest::new(
2810 InvalidationTarget::Window(self.id),
2811 InvalidationKind::Paint,
2812 ));
2813
2814 let shared_prefix_len = previous_path
2815 .iter()
2816 .zip(next_path.iter())
2817 .take_while(|(left, right)| left == right)
2818 .count();
2819
2820 for widget_id in previous_path[shared_prefix_len..].iter().rev().copied() {
2821 let event = active_snapshot.event(
2822 DragEventKind::Leave,
2823 position,
2824 Some(widget_id),
2825 DropEffect::None,
2826 None,
2827 );
2828 effects.extend(self.dispatch_direct_event(widget_id, &event));
2829 }
2830
2831 for widget_id in next_path[shared_prefix_len..].iter().copied() {
2832 let event = active_snapshot.event(
2833 DragEventKind::Enter,
2834 position,
2835 Some(widget_id),
2836 DropEffect::None,
2837 None,
2838 );
2839 effects.extend(self.dispatch_direct_event(widget_id, &event));
2840 }
2841
2842 let mut accepted = None;
2843 if let Some(target) = hit_target {
2844 let event = active_snapshot.event(
2845 DragEventKind::Over,
2846 position,
2847 Some(target),
2848 DropEffect::None,
2849 None,
2850 );
2851 let route = self.route_event(target, &event);
2852 accepted = nearest_drop_acceptance(&route.effects.drop_acceptances, &route.path);
2853 if let Some(request) = route.focus_request {
2854 effects.merge(self.apply_focus_request(request));
2855 }
2856 effects.merge(route.effects);
2857 }
2858
2859 if let Some(active) = self.active_drag.as_mut() {
2860 active.hover_path = next_path;
2861 if let Some(accepted) = accepted {
2862 active.accepted_target = Some(accepted.target);
2863 active.accepted_effect = accepted.effect;
2864 } else {
2865 active.accepted_target = None;
2866 active.accepted_effect = DropEffect::None;
2867 }
2868 }
2869
2870 effects
2871 }
2872
2873 fn finish_active_drag(&mut self, position: Point, cancelled: bool) -> EventEffects {
2874 let Some(active) = self.active_drag.take() else {
2875 return EventEffects::default();
2876 };
2877
2878 let mut effects = EventEffects::default();
2879 let outcome = if !cancelled {
2880 active
2881 .accepted_target
2882 .filter(|_| active.accepted_effect.is_some())
2883 .map(|target| DragOutcome::Dropped {
2884 target,
2885 effect: active.accepted_effect,
2886 })
2887 .unwrap_or(DragOutcome::Cancelled)
2888 } else {
2889 DragOutcome::Cancelled
2890 };
2891
2892 if let DragOutcome::Dropped { target, effect } = outcome {
2893 let event = active.event(
2894 DragEventKind::Drop,
2895 position,
2896 Some(target),
2897 effect,
2898 Some(outcome),
2899 );
2900 effects.extend(self.dispatch_direct_event(target, &event));
2901 }
2902
2903 for widget_id in active.hover_path.iter().rev().copied() {
2904 let event = active.event(
2905 DragEventKind::Leave,
2906 position,
2907 Some(widget_id),
2908 DropEffect::None,
2909 None,
2910 );
2911 effects.extend(self.dispatch_direct_event(widget_id, &event));
2912 }
2913
2914 let end_event = active.event(
2915 DragEventKind::End,
2916 position,
2917 active.accepted_target,
2918 active.accepted_effect,
2919 Some(outcome),
2920 );
2921 effects.extend(self.dispatch_direct_event(active.source, &end_event));
2922 effects.invalidations.push(InvalidationRequest::new(
2923 InvalidationTarget::Window(self.id),
2924 InvalidationKind::Paint,
2925 ));
2926 effects
2927 }
2928
2929 fn apply_wake_requests(&mut self, requests: Vec<WakeRequest>) {
2930 for request in requests {
2931 match request {
2932 WakeRequest::ScheduleTimer {
2933 token,
2934 deadline,
2935 target,
2936 } => {
2937 self.scheduled_timers.retain(|timer| timer.token != token);
2938 self.scheduled_timers.push(ScheduledTimer {
2939 token,
2940 deadline,
2941 target,
2942 });
2943 }
2944 WakeRequest::CancelTimer { token } => {
2945 self.scheduled_timers.retain(|timer| timer.token != token);
2946 self.delivering_timers.remove(&token);
2947 }
2948 WakeRequest::RegisterAsync { token, target } => {
2949 self.async_wake_targets.insert(token, target);
2950 }
2951 WakeRequest::UnregisterAsync { token } => {
2952 self.async_wake_targets.remove(&token);
2953 self.pending_async_wakeups.retain(|queued| *queued != token);
2954 }
2955 WakeRequest::RequestAnimationFrame { target } => {
2956 self.requested_animation_frames.insert(target);
2957 }
2958 }
2959 }
2960 }
2961
2962 fn apply_pointer_capture_requests(
2963 &mut self,
2964 requests: Vec<PointerCaptureRequest>,
2965 invalidations: &mut Vec<InvalidationRequest>,
2966 ) {
2967 for request in requests {
2968 match request {
2969 PointerCaptureRequest::Capture { pointer_id, target } => {
2970 self.reconcile_pointer_capture(pointer_id, Some(target), invalidations);
2971 }
2972 PointerCaptureRequest::Release { pointer_id } => {
2973 self.pointer_capture.remove(&pointer_id);
2974 }
2975 }
2976 }
2977 }
2978
2979 fn cancel_all_pointer_captures(&mut self, invalidations: &mut Vec<InvalidationRequest>) {
2980 let pointer_ids = self.pointer_capture.keys().copied().collect::<Vec<_>>();
2981 for pointer_id in pointer_ids {
2982 self.reconcile_pointer_capture(pointer_id, None, invalidations);
2983 }
2984 }
2985
2986 fn reconcile_pointer_capture(
2987 &mut self,
2988 pointer_id: u64,
2989 requested_target: Option<WidgetId>,
2990 invalidations: &mut Vec<InvalidationRequest>,
2991 ) {
2992 let mut cancelled_owners = HashSet::new();
2993
2994 loop {
2995 let current = self.pointer_capture.get(&pointer_id).copied();
2996 match (current, requested_target) {
2997 (None, Some(target)) => {
2998 self.pointer_capture.insert(pointer_id, target);
2999 return;
3000 }
3001 (None, None) => return,
3002 (Some(owner), Some(target)) if owner == target => return,
3003 (Some(owner), _) => {
3004 self.pointer_capture.remove(&pointer_id);
3005 if !cancelled_owners.insert(owner) {
3006 continue;
3010 }
3011
3012 let cancel = self.pointer_cancel_event(pointer_id);
3013 let dispatch = self.dispatch_direct_event(owner, &Event::Pointer(cancel));
3014 self.apply_pointer_cancel_dispatch(dispatch, invalidations);
3015 }
3016 }
3017 }
3018 }
3019
3020 fn pointer_cancel_event(&self, pointer_id: u64) -> PointerEvent {
3021 let mut pointer = self
3022 .last_pointer_events
3023 .get(&pointer_id)
3024 .cloned()
3025 .unwrap_or_else(|| PointerEvent::new(PointerEventKind::Cancel, Point::ZERO));
3026 pointer.pointer_id = pointer_id;
3027 pointer.kind = PointerEventKind::Cancel;
3028 pointer.delta = Vector::ZERO;
3029 pointer.scroll_delta = None;
3030 pointer.button = None;
3031 pointer.buttons = PointerButtons::NONE;
3032 pointer
3033 }
3034
3035 fn apply_pointer_cancel_dispatch(
3036 &mut self,
3037 dispatch: widget::EventDispatch,
3038 invalidations: &mut Vec<InvalidationRequest>,
3039 ) {
3040 let focus_request = dispatch.focus_request;
3041 let mut effects = EventEffects::default();
3042 effects.extend(dispatch);
3043 self.apply_event_effects(effects, invalidations);
3044
3045 if let Some(request) = focus_request {
3046 let focus_effects = self.apply_focus_request(request);
3047 self.apply_event_effects(focus_effects, invalidations);
3048 }
3049 }
3050
3051 fn finish_event(&mut self, event: &Event) {
3052 match event {
3053 Event::Pointer(pointer)
3054 if matches!(
3055 pointer.kind,
3056 PointerEventKind::Up | PointerEventKind::Cancel
3057 ) =>
3058 {
3059 self.pointer_capture.remove(&pointer.pointer_id);
3060 self.last_pointer_events.remove(&pointer.pointer_id);
3061 }
3062 Event::Wake(WakeEvent::Timer { token, .. }) => {
3063 self.delivering_timers.remove(token);
3064 }
3065 Event::Wake(WakeEvent::AnimationFrame { .. }) => {
3066 self.delivering_animation_frames.pop_front();
3067 if self.delivering_animation_frames.is_empty()
3068 && self.requested_animation_frames.is_empty()
3069 {
3070 self.last_animation_frame_time = None;
3071 }
3072 }
3073 _ => {}
3074 }
3075 }
3076
3077 fn route_event(&mut self, target: WidgetId, event: &Event) -> EventRouteResult {
3078 let path = self
3079 .graph
3080 .path_to(target)
3081 .unwrap_or_else(|| vec![self.root.id()]);
3082 let dpi_info = self.current_dpi_info();
3083 let mut effects = EventEffects::default();
3084 let mut handled = false;
3085 let mut focus_request = None;
3086 let mut route_steps = self.inspector_tracing_enabled.then(Vec::new);
3087 let target_only = matches!(event, Event::Wake(_));
3088 let ignore_handled = matches!(event, Event::Drag(_));
3089
3090 if !target_only && path.len() > 1 {
3091 for path_len in 1..path.len() {
3092 let dispatch = self
3093 .root
3094 .dispatch_event_for_path(
3095 &path[..path_len],
3096 self.id,
3097 dpi_info,
3098 self.last_tick_time,
3099 EventPhase::Capture,
3100 self.focus.focused_widget,
3101 &self.clipboard,
3102 &self.command_sender,
3103 event,
3104 )
3105 .unwrap_or_else(empty_dispatch);
3106 let dispatch_handled = dispatch.handled;
3107 let dispatch_focus_request = dispatch.focus_request;
3108 if let Some(route_steps) = &mut route_steps {
3109 route_steps.push(EventRouteStep {
3110 widget_id: path[path_len - 1],
3111 phase: EventRoutePhase::Capture,
3112 handled: dispatch_handled,
3113 });
3114 }
3115 effects.extend(dispatch);
3116 if dispatch_focus_request.is_some() {
3117 focus_request = dispatch_focus_request;
3118 }
3119 if dispatch_handled && !ignore_handled {
3120 handled = true;
3121 break;
3122 }
3123 }
3124 }
3125
3126 if !handled || ignore_handled {
3127 let dispatch = self
3128 .root
3129 .dispatch_event_for_path(
3130 &path,
3131 self.id,
3132 dpi_info,
3133 self.last_tick_time,
3134 EventPhase::Target,
3135 self.focus.focused_widget,
3136 &self.clipboard,
3137 &self.command_sender,
3138 event,
3139 )
3140 .or_else(|| {
3141 self.root.dispatch_event_for(
3142 target,
3143 self.id,
3144 dpi_info,
3145 self.last_tick_time,
3146 EventPhase::Target,
3147 self.focus.focused_widget,
3148 &self.clipboard,
3149 &self.command_sender,
3150 event,
3151 )
3152 })
3153 .unwrap_or_else(empty_dispatch);
3154 let dispatch_handled = dispatch.handled;
3155 let dispatch_focus_request = dispatch.focus_request;
3156 if let Some(route_steps) = &mut route_steps {
3157 route_steps.push(EventRouteStep {
3158 widget_id: target,
3159 phase: EventRoutePhase::Target,
3160 handled: dispatch_handled,
3161 });
3162 }
3163 effects.extend(dispatch);
3164 if dispatch_focus_request.is_some() {
3165 focus_request = dispatch_focus_request;
3166 }
3167 handled = dispatch_handled && !ignore_handled;
3168 }
3169
3170 if !target_only && (!handled || ignore_handled) && path.len() > 1 {
3171 for path_len in (1..path.len()).rev() {
3172 let dispatch = self
3173 .root
3174 .dispatch_event_for_path(
3175 &path[..path_len],
3176 self.id,
3177 dpi_info,
3178 self.last_tick_time,
3179 EventPhase::Bubble,
3180 self.focus.focused_widget,
3181 &self.clipboard,
3182 &self.command_sender,
3183 event,
3184 )
3185 .unwrap_or_else(empty_dispatch);
3186 let dispatch_handled = dispatch.handled;
3187 let dispatch_focus_request = dispatch.focus_request;
3188 if let Some(route_steps) = &mut route_steps {
3189 route_steps.push(EventRouteStep {
3190 widget_id: path[path_len - 1],
3191 phase: EventRoutePhase::Bubble,
3192 handled: dispatch_handled,
3193 });
3194 }
3195 effects.extend(dispatch);
3196 if dispatch_focus_request.is_some() {
3197 focus_request = dispatch_focus_request;
3198 }
3199 if dispatch_handled && !ignore_handled {
3200 handled = true;
3201 break;
3202 }
3203 }
3204 }
3205
3206 if let Some(route_steps) = route_steps {
3207 let trace_handled = route_steps.iter().any(|step| step.handled);
3208 let sample = EventRouteTraceSample {
3209 sequence: self.next_event_route_sequence,
3210 event_kind: inspector_event_kind(event),
3211 target,
3212 path: path.clone(),
3213 steps: route_steps,
3214 handled: trace_handled,
3215 };
3216 self.next_event_route_sequence = self.next_event_route_sequence.wrapping_add(1);
3217 push_inspector_history(&mut self.event_route_history, sample);
3218 }
3219
3220 EventRouteResult {
3221 path,
3222 effects,
3223 focus_request,
3224 handled,
3225 }
3226 }
3227
3228 fn default_focus_request(
3229 &self,
3230 event: &Event,
3231 hit_target: Option<WidgetId>,
3232 path: &[WidgetId],
3233 ) -> Option<FocusRequest> {
3234 match event {
3235 Event::Keyboard(keyboard)
3236 if keyboard.state == KeyState::Pressed
3237 && keyboard.key == "Tab"
3238 && !keyboard.repeat
3239 && !keyboard.is_composing
3240 && !keyboard.modifiers.control
3241 && !keyboard.modifiers.alt
3242 && !keyboard.modifiers.meta =>
3243 {
3244 self.overlay_manager
3245 .focus_trap()
3246 .and_then(|scope| {
3247 self.graph.next_focusable_within(
3248 scope,
3249 self.focus.focused_widget,
3250 keyboard.modifiers.shift,
3251 )
3252 })
3253 .or_else(|| {
3254 self.graph
3255 .next_focusable(self.focus.focused_widget, keyboard.modifiers.shift)
3256 })
3257 .map(FocusRequest::Focus)
3258 .or(Some(FocusRequest::Clear))
3259 }
3260 Event::Pointer(pointer) if pointer.kind == PointerEventKind::Down => {
3261 let Some(hit_target) = hit_target else {
3262 return Some(FocusRequest::Clear);
3263 };
3264
3265 path.iter()
3266 .rev()
3267 .copied()
3268 .find(|widget_id| {
3269 self.graph
3270 .node(*widget_id)
3271 .is_some_and(|node| node.accepts_focus)
3272 })
3273 .map(FocusRequest::Focus)
3274 .or(Some(FocusRequest::Clear))
3275 .filter(|request| {
3276 matches!(request, FocusRequest::Focus(id) if *id == hit_target)
3277 || matches!(request, FocusRequest::Clear)
3278 })
3279 }
3280 Event::Window(WindowEvent::Focused(false)) => Some(FocusRequest::Clear),
3281 _ => None,
3282 }
3283 }
3284
3285 fn apply_focus_request(&mut self, request: FocusRequest) -> EventEffects {
3286 let request = self.constrain_focus_request(request);
3287 self.apply_focus_request_unconstrained(request)
3288 }
3289
3290 fn apply_focus_request_unconstrained(&mut self, request: FocusRequest) -> EventEffects {
3291 let next_focus = match request {
3292 FocusRequest::Focus(widget_id) => Some(widget_id),
3293 FocusRequest::Clear => None,
3294 };
3295
3296 if self.focus.focused_widget == next_focus {
3297 if self.focused_semantics != next_focus {
3298 self.focused_semantics = next_focus;
3299 self.schedule.mark(InvalidationKind::Semantics);
3300 }
3301 return EventEffects::default();
3302 }
3303
3304 let previous_focus = self.focus.focused_widget;
3305 self.focus.focused_widget = next_focus;
3306 self.focused_semantics = next_focus;
3307 let dpi_info = self.current_dpi_info();
3308
3309 let mut effects = EventEffects::default();
3310
3311 if let Some(widget_id) = previous_focus {
3312 effects
3313 .invalidations
3314 .extend(self.focus_transition_invalidations(widget_id));
3315 let extra = self
3316 .graph
3317 .path_to(widget_id)
3318 .and_then(|path| {
3319 self.root.notify_focus_change_for_path(
3320 &path,
3321 self.id,
3322 dpi_info,
3323 self.last_tick_time,
3324 self.focus.focused_widget,
3325 &self.clipboard,
3326 &self.command_sender,
3327 false,
3328 )
3329 })
3330 .or_else(|| {
3331 self.root.notify_focus_change_for(
3332 widget_id,
3333 self.id,
3334 dpi_info,
3335 self.last_tick_time,
3336 self.focus.focused_widget,
3337 &self.clipboard,
3338 &self.command_sender,
3339 false,
3340 )
3341 });
3342 if let Some(extra) = extra {
3343 effects.extend(extra);
3344 }
3345 }
3346
3347 if let Some(widget_id) = next_focus {
3348 effects
3349 .invalidations
3350 .extend(self.focus_transition_invalidations(widget_id));
3351 let extra = self
3352 .graph
3353 .path_to(widget_id)
3354 .and_then(|path| {
3355 self.root.notify_focus_change_for_path(
3356 &path,
3357 self.id,
3358 dpi_info,
3359 self.last_tick_time,
3360 self.focus.focused_widget,
3361 &self.clipboard,
3362 &self.command_sender,
3363 true,
3364 )
3365 })
3366 .or_else(|| {
3367 self.root.notify_focus_change_for(
3368 widget_id,
3369 self.id,
3370 dpi_info,
3371 self.last_tick_time,
3372 self.focus.focused_widget,
3373 &self.clipboard,
3374 &self.command_sender,
3375 true,
3376 )
3377 });
3378 if let Some(extra) = extra {
3379 effects.extend(extra);
3380 }
3381 }
3382
3383 self.schedule.mark(InvalidationKind::Paint);
3384 self.schedule.mark(InvalidationKind::Semantics);
3385 self.schedule.mark(InvalidationKind::HitTest);
3386 self.graph.set_focused_widget(self.focus.focused_widget);
3387
3388 effects
3389 }
3390
3391 fn constrain_focus_request(&self, request: FocusRequest) -> FocusRequest {
3392 let Some(scope) = self.overlay_manager.focus_trap() else {
3393 return request;
3394 };
3395 match request {
3396 FocusRequest::Focus(widget_id)
3397 if widget_id == scope || self.graph.is_ancestor_of(scope, widget_id) =>
3398 {
3399 return request;
3400 }
3401 FocusRequest::Focus(_) | FocusRequest::Clear => {}
3402 }
3403
3404 self.focus
3405 .focused_widget
3406 .filter(|focused| *focused == scope || self.graph.is_ancestor_of(scope, *focused))
3407 .or_else(|| self.graph.first_focusable_within(scope, true))
3408 .map(FocusRequest::Focus)
3409 .unwrap_or(FocusRequest::Clear)
3410 }
3411
3412 fn apply_pending_overlay_focus(&mut self, invalidations: &mut Vec<InvalidationRequest>) {
3413 let Some(request) = self.pending_overlay_focus.take() else {
3414 return;
3415 };
3416 let effects = self.apply_focus_request(request);
3417 self.apply_event_effects(effects, invalidations);
3418 }
3419
3420 fn focus_transition_invalidations(&self, widget_id: WidgetId) -> Vec<InvalidationRequest> {
3421 let mut invalidations = vec![InvalidationRequest::new(
3422 InvalidationTarget::Widget(widget_id),
3423 InvalidationKind::Semantics,
3424 )];
3425
3426 if let Some(node) = self.graph.node(widget_id) {
3427 invalidations.push(
3428 InvalidationRequest::new(
3429 InvalidationTarget::Widget(widget_id),
3430 InvalidationKind::Paint,
3431 )
3432 .with_region(node.geometry.paint_bounds),
3433 );
3434 }
3435
3436 invalidations
3437 }
3438
3439 fn render(
3440 &mut self,
3441 text_system: Arc<TextSystem>,
3442 font_registry: Arc<FontRegistry>,
3443 image_registry: Arc<ImageRegistry>,
3444 ) -> RenderOutput {
3445 let diagnostics_enabled = window_scene_statistics_detail_mode(self.id).is_detailed();
3446 let mut diagnostics = RenderDiagnostics::default();
3447 let mut invalidations = std::mem::take(&mut self.pending_invalidations);
3448 let mut repainted = false;
3449 let mut repaint_layers = Vec::new();
3450 let mut dirty_layers = Vec::new();
3451 let mut layer_updates = Vec::new();
3452 let previous_graph =
3453 if (self.schedule.measure || self.schedule.arrange) && !self.graph.is_empty() {
3454 Some(self.graph.snapshot())
3455 } else {
3456 None
3457 };
3458 let mut graph_changes = GraphChangeSet::default();
3459
3460 if self.last_frame.is_none() {
3461 self.schedule = FrameSchedule::bootstrap();
3462 }
3463
3464 if self.schedule.measure || self.schedule.arrange || self.viewport.is_none() {
3465 let started = Instant::now();
3466 let pass_invalidations = self.run_measure_arrange_pass(
3467 &invalidations,
3468 Arc::clone(&text_system),
3469 Arc::clone(&font_registry),
3470 Arc::clone(&image_registry),
3471 );
3472 self.schedule.extend(&pass_invalidations);
3473 invalidations.extend(pass_invalidations);
3474 graph_changes = self.collect_graph_changes(previous_graph.as_ref());
3475 if diagnostics_enabled {
3476 diagnostics.push(FramePhase::MeasureArrange, started.elapsed());
3477 }
3478 } else if self.schedule.hit_test || self.graph.is_empty() {
3479 let started = Instant::now();
3480 self.refresh_graph();
3481 if diagnostics_enabled {
3482 diagnostics.push(FramePhase::HitTest, started.elapsed());
3483 }
3484 }
3485
3486 self.apply_pending_overlay_focus(&mut invalidations);
3487
3488 let viewport = self.viewport.unwrap_or(Size::ZERO);
3489 let dpi_info = self.dpi_info_for_viewport(viewport);
3490 let previous_scene = self.last_frame.as_ref().map(|frame| &frame.scene);
3491 let mut composition_only_transforms = self
3492 .select_composition_only_transforms(previous_scene, &graph_changes.transform_widgets);
3493 for translation in
3494 self.select_explicit_transform_translations(previous_scene, &invalidations)
3495 {
3496 if composition_only_transforms
3497 .iter()
3498 .all(|existing| existing.widget_id != translation.widget_id)
3499 {
3500 composition_only_transforms.push(translation);
3501 }
3502 }
3503 let previous_scene_for_refresh = self.last_frame.as_ref().map(|frame| frame.scene.clone());
3504 let layer_descriptor_refreshes = self.collect_explicit_layer_descriptor_refreshes(
3505 previous_scene_for_refresh.as_ref(),
3506 &invalidations,
3507 );
3508 let composition_only_transform_ids = composition_only_transforms
3509 .iter()
3510 .map(|translation| translation.widget_id)
3511 .collect::<HashSet<_>>();
3512 let mut repaint_graph_widgets = graph_changes.repaint_widgets.clone();
3513 for translation in &graph_changes.transform_widgets {
3514 if !composition_only_transform_ids.contains(&translation.widget_id) {
3515 repaint_graph_widgets.push(translation.widget_id);
3516 }
3517 }
3518
3519 if self.schedule.paint || self.last_frame.is_none() || !repaint_graph_widgets.is_empty() {
3520 repaint_layers = self.collect_dirty_layers(&invalidations);
3521 dirty_layers = repaint_layers.clone();
3522 for widget_id in repaint_graph_widgets.iter().copied() {
3523 if self.graph.contains(widget_id) && !dirty_layers.contains(&widget_id) {
3524 dirty_layers.push(widget_id);
3525 }
3526 if self.graph.contains(widget_id) && !repaint_layers.contains(&widget_id) {
3527 repaint_layers.push(widget_id);
3528 }
3529 }
3530
3531 let mixed_update_roots = composition_only_transforms
3536 .iter()
3537 .filter(|translation| {
3538 dirty_layers.iter().any(|dirty_widget| {
3539 self.widget_is_ancestor_of(translation.widget_id, *dirty_widget)
3540 })
3541 })
3542 .map(|translation| translation.widget_id)
3543 .collect::<Vec<_>>();
3544 repaint_layers.extend(mixed_update_roots.iter().copied());
3545 dirty_layers.extend(mixed_update_roots);
3546 self.minimize_layer_roots(&mut repaint_layers);
3547 self.minimize_layer_roots(&mut dirty_layers);
3548
3549 composition_only_transforms.retain(|translation| {
3550 !dirty_layers.iter().any(|dirty_widget| {
3551 *dirty_widget == translation.widget_id
3552 || self.widget_is_ancestor_of(*dirty_widget, translation.widget_id)
3553 })
3554 });
3555 }
3556
3557 let mut scene_changed = false;
3558 let has_ordering_updates = invalidations
3559 .iter()
3560 .any(|request| request.kind == InvalidationKind::Ordering);
3561 if self.last_frame.is_none()
3562 || !repaint_layers.is_empty()
3563 || !composition_only_transforms.is_empty()
3564 || !layer_descriptor_refreshes.is_empty()
3565 || has_ordering_updates
3566 {
3567 let started = Instant::now();
3568 repainted = self.last_frame.is_none() || !repaint_layers.is_empty();
3569 scene_changed = true;
3570
3571 let focused_path = self
3572 .focus
3573 .focused_widget
3574 .and_then(|widget_id| self.graph.path_to(widget_id));
3575 let preserve_ime = focused_path.as_ref().is_none_or(|path| {
3576 !repaint_layers
3577 .iter()
3578 .any(|widget_id| path.iter().any(|candidate| candidate == widget_id))
3579 });
3580 let baseline_ime_composition_rect = if preserve_ime {
3581 self.ime_composition_rect
3582 } else {
3583 None
3584 };
3585
3586 let (
3587 scene,
3588 paint_images,
3589 mut paint_bounds_by_widget,
3590 paint_invalidations,
3591 mut ime_composition_rect,
3592 ) = if self.last_frame.is_none() || repaint_layers.contains(&self.root.id()) {
3593 self.paint_full_scene(
3594 dpi_info,
3595 Arc::clone(&text_system),
3596 Arc::clone(&font_registry),
3597 Arc::clone(&image_registry),
3598 )
3599 } else if repaint_layers.is_empty() {
3600 (
3601 self.last_frame
3602 .as_ref()
3603 .map(|frame| frame.scene.clone())
3604 .unwrap_or_default(),
3605 Vec::new(),
3606 self.last_paint_bounds_by_widget.clone(),
3607 Vec::new(),
3608 baseline_ime_composition_rect,
3609 )
3610 } else {
3611 self.repaint_dirty_layers(
3612 dpi_info,
3613 &repaint_layers,
3614 baseline_ime_composition_rect,
3615 Arc::clone(&text_system),
3616 Arc::clone(&font_registry),
3617 Arc::clone(&image_registry),
3618 )
3619 };
3620 let mut scene = scene;
3621 for translation in &composition_only_transforms {
3622 let _ = scene.translate_layer(translation.widget_id, translation.delta);
3623 for widget_id in self.graph.subtree_ids(translation.widget_id) {
3624 if let Some(bounds) = paint_bounds_by_widget.get_mut(&widget_id) {
3625 *bounds = bounds.translate(translation.delta);
3626 }
3627 }
3628 if let Some(moved_bounds) =
3629 paint_bounds_by_widget.get(&translation.widget_id).copied()
3630 {
3631 let mut ancestor = self
3637 .graph
3638 .node(translation.widget_id)
3639 .and_then(|node| node.parent);
3640 while let Some(widget_id) = ancestor {
3641 paint_bounds_by_widget
3642 .entry(widget_id)
3643 .and_modify(|bounds| *bounds = bounds.union(moved_bounds))
3644 .or_insert(moved_bounds);
3645 ancestor = self.graph.node(widget_id).and_then(|node| node.parent);
3646 }
3647 }
3648 if focused_path
3649 .as_ref()
3650 .is_some_and(|path| path.contains(&translation.widget_id))
3651 {
3652 ime_composition_rect =
3653 ime_composition_rect.map(|rect| rect.translate(translation.delta));
3654 }
3655 }
3656 for refresh in &layer_descriptor_refreshes {
3657 let _ =
3658 scene.replace_layer_descriptor(refresh.widget_id, refresh.descriptor.clone());
3659 }
3660 self.sync_scene_stack_metadata(&mut scene);
3661 self.last_paint_bounds_by_widget = paint_bounds_by_widget;
3662 self.graph
3663 .update_paint_bounds_from_snapshot(&self.last_paint_bounds_by_widget);
3664 invalidations.extend(paint_invalidations);
3665 self.ime_composition_rect = ime_composition_rect;
3666 let previous_scene = self.last_frame.as_ref().map(|frame| &frame.scene);
3667 layer_updates = self.collect_layer_updates(
3668 previous_scene,
3669 &scene,
3670 &invalidations,
3671 &dirty_layers,
3672 &composition_only_transforms
3673 .iter()
3674 .map(|translation| translation.widget_id)
3675 .collect::<Vec<_>>(),
3676 );
3677 let frame_image_registry =
3678 self.frame_image_registry(Arc::clone(&image_registry), paint_images);
3679 retain_text_layouts_for_scene(text_system.as_ref(), &scene);
3680 self.last_frame = Some(SceneFrame {
3681 window_id: self.id,
3682 viewport,
3683 surface_size: dpi_info.surface_size,
3684 scale_factor: dpi_info.scale_factor,
3685 dirty_regions: Vec::new(),
3686 layer_updates: layer_updates.clone(),
3687 scene,
3688 font_registry: Arc::clone(&font_registry),
3689 image_registry: frame_image_registry,
3690 text_layout_registry: text_system.text_layout_registry(),
3691 });
3692 if diagnostics_enabled && repainted {
3693 diagnostics.push(FramePhase::Paint, started.elapsed());
3694 }
3695 }
3696
3697 if self.schedule.semantics || self.last_semantics.is_empty() {
3698 let started = Instant::now();
3699 let mut semantics_ctx = SemanticsCtx::new(
3700 self.id,
3701 self.root.id(),
3702 self.root.id(),
3703 self.root.bounds(),
3704 self.focus.focused_widget,
3705 );
3706 self.root.semantics(&mut semantics_ctx);
3707 let semantics = self.assemble_semantics_tree(semantics_ctx.into_nodes());
3708 self.last_semantics = self.filter_modal_semantics(semantics);
3709 if diagnostics_enabled {
3710 diagnostics.push(FramePhase::Semantics, started.elapsed());
3711 }
3712 }
3713
3714 let viewport_rect = Rect::from_origin_size(Point::ZERO, viewport);
3715 let dirty_regions = collect_dirty_regions(viewport, &invalidations, repainted, |request| {
3716 self.default_dirty_region_for_request(viewport_rect, request)
3717 });
3718 let mut frame = self
3719 .last_frame
3720 .clone()
3721 .unwrap_or_else(|| SceneFrame::new(self.id, viewport));
3722 frame.viewport = viewport;
3723 frame.surface_size = dpi_info.surface_size;
3724 frame.scale_factor = dpi_info.scale_factor;
3725 frame.dirty_regions = dirty_regions;
3726 frame.layer_updates = if scene_changed {
3727 layer_updates
3728 } else {
3729 self.collect_layer_updates(
3730 self.last_frame.as_ref().map(|stored| &stored.scene),
3731 &frame.scene,
3732 &invalidations,
3733 &[],
3734 &composition_only_transforms
3735 .iter()
3736 .map(|translation| translation.widget_id)
3737 .collect::<Vec<_>>(),
3738 )
3739 };
3740 frame.font_registry = font_registry;
3741 frame.image_registry = self.frame_image_registry(image_registry, Vec::new());
3742
3743 if diagnostics_enabled {
3744 let layout_cache = text_system.layout_cache_snapshot();
3745 diagnostics.text_caches.runtime_layout =
3746 CacheMetrics::new(layout_cache.entries, layout_cache.hits, layout_cache.misses);
3747 }
3748
3749 diagnostics.widget_count = self.graph.nodes.len();
3750 diagnostics.runtime_text_timing = sui_text::take_text_timing_collection();
3751 diagnostics.widget_timings = diagnostics::take_widget_timing_collection();
3752 diagnostics.reactive_invalidations = std::mem::take(&mut self.pending_reactive_diagnostics);
3753 diagnostics.command_dispatches = std::mem::take(&mut self.pending_command_diagnostics);
3754 diagnostics.invalidations = std::mem::take(&mut self.pending_invalidation_diagnostics);
3755 diagnostics.widget_rebuilds = diagnostics::take_widget_rebuilds(self.id);
3756 diagnostics.active_animated_widget_count = self.active_animated_widget_count();
3757 diagnostics.animation_frame_wake_count = self.pending_animation_wake_count;
3758 diagnostics.animation_repaint_frame_count =
3759 usize::from(self.pending_animation_wake_count > 0 && repainted);
3760 diagnostics.animation_transform_effect_only_frame_count = usize::from(
3761 self.pending_animation_wake_count > 0
3762 && self.animation_frame_is_transform_only(repainted, &frame.layer_updates),
3763 );
3764 self.pending_animation_wake_count = 0;
3765
3766 self.capture_inspector_diagnostics(&diagnostics);
3767
3768 self.schedule.clear();
3769
3770 RenderOutput {
3771 title: self.title.clone(),
3772 frame,
3773 semantics: self.last_semantics.clone(),
3774 ime_composition_rect: self.ime_composition_rect,
3775 diagnostics,
3776 }
3777 }
3778
3779 fn frame_image_registry(
3780 &self,
3781 base: Arc<ImageRegistry>,
3782 paint_images: Vec<(ImageHandle, PaintImageResource)>,
3783 ) -> Arc<ImageRegistry> {
3784 let mut registry = self
3785 .last_frame
3786 .as_ref()
3787 .map(|frame| frame.image_registry.as_ref().clone())
3788 .unwrap_or_else(|| base.as_ref().clone());
3789 for (handle, image) in base.iter() {
3790 registry.insert(handle, image.clone());
3791 }
3792 for (handle, image) in base.iter_external() {
3793 registry.insert_external(handle, *image);
3794 }
3795 for (handle, image) in paint_images {
3796 match image {
3797 PaintImageResource::Cpu(image) => {
3798 registry.insert(handle, image);
3799 }
3800 PaintImageResource::External(image) => {
3801 registry.insert_external(handle, image);
3802 }
3803 }
3804 }
3805 Arc::new(registry)
3806 }
3807
3808 fn paint_full_scene(
3809 &mut self,
3810 dpi_info: DpiInfo,
3811 text_system: Arc<TextSystem>,
3812 font_registry: Arc<FontRegistry>,
3813 image_registry: Arc<ImageRegistry>,
3814 ) -> PaintOutput {
3815 let mut paint_ctx = PaintCtx::new(
3816 self.id,
3817 self.root.id(),
3818 self.root.bounds(),
3819 self.focus.focused_widget,
3820 dpi_info,
3821 text_system,
3822 font_registry,
3823 self.last_frame
3824 .as_ref()
3825 .map(|frame| Arc::clone(&frame.image_registry))
3826 .unwrap_or(image_registry),
3827 );
3828 let _ = self
3829 .root
3830 .paint_layer_contents_for(self.root.id(), &mut paint_ctx);
3831 paint_ctx.into_parts()
3832 }
3833
3834 fn repaint_dirty_layers(
3835 &mut self,
3836 dpi_info: DpiInfo,
3837 dirty_layers: &[WidgetId],
3838 baseline_ime_composition_rect: Option<Rect>,
3839 text_system: Arc<TextSystem>,
3840 font_registry: Arc<FontRegistry>,
3841 image_registry: Arc<ImageRegistry>,
3842 ) -> PaintOutput {
3843 let mut scene = self
3844 .last_frame
3845 .as_ref()
3846 .map(|frame| frame.scene.clone())
3847 .unwrap_or_default();
3848 let mut images = Vec::new();
3849 let mut invalidations = Vec::new();
3850 let mut paint_bounds_by_widget = self.last_paint_bounds_by_widget.clone();
3851 let mut ime_composition_rect = baseline_ime_composition_rect;
3852
3853 for &widget_id in dirty_layers {
3854 let Some(bounds) = self
3855 .graph
3856 .node(widget_id)
3857 .map(|node| node.geometry.layout_bounds)
3858 else {
3859 return self.paint_full_scene(dpi_info, text_system, font_registry, image_registry);
3860 };
3861
3862 let mut paint_ctx = PaintCtx::new(
3863 self.id,
3864 widget_id,
3865 bounds,
3866 self.focus.focused_widget,
3867 dpi_info,
3868 Arc::clone(&text_system),
3869 Arc::clone(&font_registry),
3870 self.last_frame
3871 .as_ref()
3872 .map(|frame| Arc::clone(&frame.image_registry))
3873 .unwrap_or_else(|| Arc::clone(&image_registry)),
3874 );
3875 if !self
3876 .root
3877 .paint_layer_contents_for(widget_id, &mut paint_ctx)
3878 {
3879 return self.paint_full_scene(dpi_info, text_system, font_registry, image_registry);
3880 }
3881
3882 let (
3883 layer_scene,
3884 layer_images,
3885 layer_paint_bounds,
3886 layer_invalidations,
3887 layer_ime_composition_rect,
3888 ) = paint_ctx.into_parts();
3889 let Some(descriptor) = self.root.layer_descriptor_for(widget_id, &layer_scene) else {
3890 return self.paint_full_scene(dpi_info, text_system, font_registry, image_registry);
3891 };
3892 if widget_id == self.root.id()
3893 || !scene.replace_layer(
3894 widget_id,
3895 SceneLayer::from_descriptor(descriptor, layer_scene),
3896 )
3897 {
3898 return self.paint_full_scene(dpi_info, text_system, font_registry, image_registry);
3899 }
3900
3901 images.extend(layer_images);
3902 paint_bounds_by_widget.extend(layer_paint_bounds);
3903 invalidations.extend(layer_invalidations);
3904 if layer_ime_composition_rect.is_some() {
3905 ime_composition_rect = layer_ime_composition_rect;
3906 }
3907 }
3908
3909 (
3910 scene,
3911 images,
3912 paint_bounds_by_widget,
3913 invalidations,
3914 ime_composition_rect,
3915 )
3916 }
3917
3918 fn collect_dirty_layers(&self, invalidations: &[InvalidationRequest]) -> Vec<WidgetId> {
3919 let candidates: HashSet<WidgetId> = invalidations
3920 .iter()
3921 .filter(|request| {
3922 matches!(
3923 request.kind,
3924 InvalidationKind::Measure
3925 | InvalidationKind::Clip
3926 | InvalidationKind::Visibility
3927 | InvalidationKind::Paint
3928 | InvalidationKind::Text
3929 | InvalidationKind::Resources
3930 )
3931 })
3932 .map(|request| match request.target {
3933 InvalidationTarget::Widget(widget_id) if self.graph.contains(widget_id) => self
3934 .graph
3935 .nearest_paint_boundary_ancestor_or_root(widget_id),
3936 InvalidationTarget::Widget(_) => self.root.id(),
3937 InvalidationTarget::Window(_) | InvalidationTarget::Surface(_) => self.root.id(),
3938 })
3939 .collect();
3940
3941 if self.last_frame.is_none() || candidates.contains(&self.root.id()) {
3942 return vec![self.root.id()];
3943 }
3944
3945 let mut candidates: Vec<_> = candidates
3946 .into_iter()
3947 .filter(|widget_id| self.graph.contains(*widget_id))
3948 .collect();
3949 candidates.sort_by_key(|widget_id| {
3950 self.graph
3951 .path_to(*widget_id)
3952 .map_or(usize::MAX, |path| path.len())
3953 });
3954
3955 let mut minimized = Vec::new();
3956 for widget_id in candidates {
3957 if minimized
3958 .iter()
3959 .any(|ancestor| self.widget_is_ancestor_of(*ancestor, widget_id))
3960 {
3961 continue;
3962 }
3963 minimized.push(widget_id);
3964 }
3965
3966 minimized
3967 }
3968
3969 fn collect_graph_changes(&self, previous: Option<&WidgetGraphSnapshot>) -> GraphChangeSet {
3970 let Some(previous) = previous else {
3971 return GraphChangeSet {
3972 repaint_widgets: vec![self.graph.root],
3973 transform_widgets: Vec::new(),
3974 };
3975 };
3976
3977 let current_snapshot = self.graph.snapshot();
3978 let previous_nodes: HashMap<_, _> =
3979 previous.nodes.iter().map(|node| (node.id, node)).collect();
3980 let current_nodes: HashMap<_, _> = current_snapshot
3981 .nodes
3982 .iter()
3983 .map(|node| (node.id, node))
3984 .collect();
3985 let widget_ids = previous_nodes
3986 .keys()
3987 .chain(current_nodes.keys())
3988 .copied()
3989 .collect::<HashSet<_>>();
3990 let mut repaint_candidates = HashSet::new();
3991 let mut transform_candidates = Vec::new();
3992
3993 for widget_id in widget_ids {
3994 match (
3995 previous_nodes.get(&widget_id),
3996 current_nodes.get(&widget_id),
3997 ) {
3998 (Some(previous_node), Some(current_node)) => {
3999 if previous_node.measured_size != current_node.measured_size
4000 || previous_node.geometry.layout_bounds.size
4001 != current_node.geometry.layout_bounds.size
4002 || previous_node.parent != current_node.parent
4003 || previous_node.children != current_node.children
4004 {
4005 repaint_candidates.insert(resolve_snapshot_paint_boundary_or_root(
4006 ¤t_snapshot,
4007 current_node.id,
4008 ));
4009 continue;
4010 }
4011
4012 let delta = current_node.geometry.layout_bounds.origin
4013 - previous_node.geometry.layout_bounds.origin;
4014 if delta != Vector::ZERO {
4015 let resolved_boundary = resolve_snapshot_paint_boundary_or_root(
4016 ¤t_snapshot,
4017 current_node.id,
4018 );
4019 if resolved_boundary == current_node.id
4020 && current_node.paint_boundary == PaintBoundaryMode::Explicit
4021 {
4022 transform_candidates.push(LayerTranslation {
4023 widget_id: current_node.id,
4024 delta,
4025 });
4026 } else if current_nodes
4027 .get(&resolved_boundary)
4028 .zip(previous_nodes.get(&resolved_boundary))
4029 .is_some_and(|(current_boundary, previous_boundary)| {
4030 current_boundary.paint_boundary == PaintBoundaryMode::Explicit
4031 && current_boundary.geometry.layout_bounds.origin
4032 - previous_boundary.geometry.layout_bounds.origin
4033 == delta
4034 })
4035 {
4036 } else {
4041 repaint_candidates.insert(resolved_boundary);
4042 }
4043 }
4044 }
4045 (None, Some(current_node)) => {
4046 repaint_candidates.insert(resolve_snapshot_paint_boundary_or_root(
4047 ¤t_snapshot,
4048 current_node.id,
4049 ));
4050 }
4051 (Some(previous_node), None) => {
4052 repaint_candidates.insert(resolve_snapshot_paint_boundary_or_root(
4053 previous,
4054 previous_node.id,
4055 ));
4056 }
4057 (None, None) => {}
4058 }
4059 }
4060
4061 let mut repaint_widgets = repaint_candidates.into_iter().collect::<Vec<_>>();
4062 repaint_widgets.sort_by_key(|widget_id| self.widget_depth(*widget_id));
4063 let mut minimized_repaint = Vec::new();
4064 for widget_id in repaint_widgets {
4065 if minimized_repaint
4066 .iter()
4067 .any(|ancestor| self.widget_is_ancestor_of(*ancestor, widget_id))
4068 {
4069 continue;
4070 }
4071 minimized_repaint.push(widget_id);
4072 }
4073
4074 transform_candidates.sort_by_key(|translation| self.widget_depth(translation.widget_id));
4075 let mut minimized_transforms = Vec::new();
4076 for candidate in transform_candidates {
4077 if minimized_repaint
4078 .iter()
4079 .any(|ancestor| self.widget_is_ancestor_of(*ancestor, candidate.widget_id))
4080 {
4081 continue;
4082 }
4083
4084 let inherited_delta = minimized_transforms
4085 .iter()
4086 .filter(|translation: &&LayerTranslation| {
4087 self.widget_is_ancestor_of(translation.widget_id, candidate.widget_id)
4088 })
4089 .fold(Vector::ZERO, |current, translation| {
4090 current + translation.delta
4091 });
4092 let residual = candidate.delta - inherited_delta;
4093 if residual == Vector::ZERO {
4094 continue;
4095 }
4096
4097 minimized_transforms.push(LayerTranslation {
4098 widget_id: candidate.widget_id,
4099 delta: residual,
4100 });
4101 }
4102
4103 GraphChangeSet {
4104 repaint_widgets: minimized_repaint,
4105 transform_widgets: minimized_transforms,
4106 }
4107 }
4108
4109 fn select_composition_only_transforms(
4110 &self,
4111 previous_scene: Option<&Scene>,
4112 transform_widgets: &[LayerTranslation],
4113 ) -> Vec<LayerTranslation> {
4114 let previous_layers = previous_scene.map(collect_scene_layers).unwrap_or_default();
4115 transform_widgets
4116 .iter()
4117 .copied()
4118 .filter(|translation| previous_layers.contains_key(&translation.widget_id))
4119 .collect()
4120 }
4121
4122 fn select_explicit_transform_translations(
4123 &self,
4124 previous_scene: Option<&Scene>,
4125 invalidations: &[InvalidationRequest],
4126 ) -> Vec<LayerTranslation> {
4127 let previous_layers = previous_scene.map(collect_scene_layers).unwrap_or_default();
4128 let mut translations = Vec::new();
4129
4130 for request in invalidations {
4131 if request.kind != InvalidationKind::Transform {
4132 continue;
4133 }
4134
4135 let InvalidationTarget::Widget(widget_id) = request.target else {
4136 continue;
4137 };
4138 let resolved_boundary = self
4139 .graph
4140 .nearest_paint_boundary_ancestor_or_root(widget_id);
4141 if resolved_boundary == self.root.id() {
4142 continue;
4143 }
4144 let Some(previous) = previous_layers.get(&resolved_boundary) else {
4145 continue;
4146 };
4147 let Some(current) = self.graph.node(resolved_boundary) else {
4148 continue;
4149 };
4150
4151 let delta = current.geometry.layout_bounds.origin - previous.bounds.origin;
4152 if delta == Vector::ZERO {
4153 continue;
4154 }
4155
4156 if translations
4157 .iter()
4158 .all(|translation: &LayerTranslation| translation.widget_id != resolved_boundary)
4159 {
4160 translations.push(LayerTranslation {
4161 widget_id: resolved_boundary,
4162 delta,
4163 });
4164 }
4165 }
4166
4167 translations
4168 }
4169
4170 fn collect_explicit_layer_descriptor_refreshes(
4171 &mut self,
4172 previous_scene: Option<&Scene>,
4173 invalidations: &[InvalidationRequest],
4174 ) -> Vec<LayerDescriptorRefresh> {
4175 let Some(previous_scene) = previous_scene else {
4176 return Vec::new();
4177 };
4178 if !invalidations.iter().any(|request| {
4179 matches!(
4180 request.kind,
4181 InvalidationKind::Transform | InvalidationKind::Effect
4182 )
4183 }) {
4184 return Vec::new();
4185 }
4186
4187 let previous_layers = collect_scene_layers(previous_scene);
4188 let mut refreshes = Vec::new();
4189
4190 for (widget_id, previous_descriptor) in previous_layers {
4191 let Some(layer_scene) = previous_scene.layer_scene(widget_id).cloned() else {
4192 continue;
4193 };
4194 let Some(descriptor) = self.root.layer_descriptor_for(widget_id, &layer_scene) else {
4195 continue;
4196 };
4197 if descriptor.properties == previous_descriptor.properties {
4198 continue;
4199 }
4200 refreshes.push(LayerDescriptorRefresh {
4201 widget_id,
4202 descriptor,
4203 });
4204 }
4205
4206 refreshes
4207 }
4208
4209 fn widget_depth(&self, widget_id: WidgetId) -> usize {
4210 self.graph.depth(widget_id).unwrap_or(usize::MAX)
4211 }
4212
4213 fn minimize_layer_roots(&self, candidates: &mut Vec<WidgetId>) {
4214 candidates.sort_by_key(|widget_id| (self.widget_depth(*widget_id), widget_id.get()));
4215 candidates.dedup();
4216 let mut minimized = Vec::with_capacity(candidates.len());
4217 for widget_id in candidates.iter().copied() {
4218 if minimized
4219 .iter()
4220 .any(|ancestor| self.widget_is_ancestor_of(*ancestor, widget_id))
4221 {
4222 continue;
4223 }
4224 minimized.push(widget_id);
4225 }
4226 *candidates = minimized;
4227 }
4228
4229 fn default_dirty_region_for_request(
4230 &self,
4231 viewport_rect: Rect,
4232 request: &InvalidationRequest,
4233 ) -> Rect {
4234 match request.target {
4235 InvalidationTarget::Widget(widget_id) => self
4236 .graph
4237 .node(widget_id)
4238 .map(|node| node.geometry.paint_bounds)
4239 .unwrap_or(viewport_rect),
4240 InvalidationTarget::Window(_) | InvalidationTarget::Surface(_) => viewport_rect,
4241 }
4242 }
4243
4244 fn collect_layer_updates(
4245 &self,
4246 previous_scene: Option<&Scene>,
4247 scene: &Scene,
4248 invalidations: &[InvalidationRequest],
4249 dirty_layers: &[WidgetId],
4250 graph_dirty_widgets: &[WidgetId],
4251 ) -> Vec<SceneLayerUpdate> {
4252 let current_layers = collect_scene_layers(scene);
4253 if current_layers.is_empty() {
4254 return Vec::new();
4255 }
4256
4257 let previous_layers = previous_scene.map(collect_scene_layers).unwrap_or_default();
4258 let mut updates = HashMap::<WidgetId, SceneLayerUpdateKind>::new();
4259 let mut damage_regions = HashMap::<WidgetId, Rect>::new();
4260 let explicit_transform_widgets = invalidations
4261 .iter()
4262 .filter_map(|request| {
4263 if request.kind != InvalidationKind::Transform {
4264 return None;
4265 }
4266
4267 match request.target {
4268 InvalidationTarget::Widget(widget_id) if self.graph.contains(widget_id) => {
4269 Some(
4270 self.graph
4271 .nearest_paint_boundary_ancestor_or_root(widget_id),
4272 )
4273 }
4274 _ => None,
4275 }
4276 })
4277 .collect::<HashSet<_>>();
4278
4279 for request in invalidations {
4280 let Some(kind) = invalidation_to_layer_update_kind(request.kind) else {
4281 continue;
4282 };
4283 let widget_id = match request.target {
4284 InvalidationTarget::Widget(widget_id) if self.graph.contains(widget_id) => self
4285 .graph
4286 .nearest_paint_boundary_ancestor_or_root(widget_id),
4287 InvalidationTarget::Widget(_) => self.root.id(),
4288 InvalidationTarget::Window(_) | InvalidationTarget::Surface(_) => self.root.id(),
4289 };
4290 if request.kind == InvalidationKind::Arrange
4291 && explicit_transform_widgets
4292 .iter()
4293 .any(|candidate| self.widget_is_ancestor_of(widget_id, *candidate))
4294 {
4295 continue;
4296 }
4297 merge_layer_update_kind(&mut updates, widget_id, kind);
4298 if let Some(region) = request.region {
4299 damage_regions
4300 .entry(widget_id)
4301 .and_modify(|current| *current = current.union(region))
4302 .or_insert(region);
4303 }
4304 }
4305
4306 for (widget_id, descriptor) in ¤t_layers {
4307 let Some(previous) = previous_layers.get(widget_id) else {
4308 merge_layer_update_kind(&mut updates, *widget_id, SceneLayerUpdateKind::Content);
4309 continue;
4310 };
4311 if descriptor.stack_host != previous.stack_host
4312 || descriptor.stack_order != previous.stack_order
4313 || descriptor.transient_owner_surface != previous.transient_owner_surface
4314 || descriptor.is_stack_surface != previous.is_stack_surface
4315 {
4316 merge_layer_update_kind(&mut updates, *widget_id, SceneLayerUpdateKind::Ordering);
4317 }
4318 if descriptor.properties.translation != previous.properties.translation {
4319 merge_layer_update_kind(&mut updates, *widget_id, SceneLayerUpdateKind::Transform);
4320 }
4321 if descriptor.properties.opacity != previous.properties.opacity {
4322 merge_layer_update_kind(&mut updates, *widget_id, SceneLayerUpdateKind::Effect);
4323 }
4324 }
4325
4326 for widget_id in graph_dirty_widgets.iter().copied() {
4327 merge_layer_update_kind(&mut updates, widget_id, SceneLayerUpdateKind::Transform);
4328 }
4329
4330 for widget_id in dirty_layers.iter().copied() {
4331 merge_layer_update_kind(&mut updates, widget_id, SceneLayerUpdateKind::Content);
4332 }
4333
4334 let mut resolved_updates = Vec::new();
4335 for (widget_id, kind) in updates {
4336 let Some(descriptor) = current_layers.get(&widget_id).cloned() else {
4337 continue;
4338 };
4339 let fallback_damage = previous_layers
4340 .get(&widget_id)
4341 .map(|previous| {
4342 previous
4343 .presented_paint_bounds()
4344 .union(descriptor.presented_paint_bounds())
4345 })
4346 .unwrap_or(descriptor.presented_paint_bounds());
4347 let damage = damage_regions
4348 .get(&widget_id)
4349 .copied()
4350 .unwrap_or(fallback_damage);
4351 resolved_updates
4352 .push(SceneLayerUpdate::from_descriptor(kind, descriptor).with_damage(damage));
4353 }
4354
4355 resolved_updates.sort_by_key(|update| update.owner.get());
4356 resolved_updates
4357 }
4358
4359 fn widget_is_ancestor_of(&self, ancestor: WidgetId, widget_id: WidgetId) -> bool {
4360 self.graph.is_ancestor_of(ancestor, widget_id)
4361 }
4362
4363 fn build_measure_scope(&self, invalidations: &[InvalidationRequest]) -> Rc<MeasureScope> {
4372 let mut subtree_roots: HashSet<WidgetId> = HashSet::new();
4373 let mut force_all = false;
4374 for request in invalidations {
4375 if !matches!(
4376 request.kind,
4377 InvalidationKind::Measure
4378 | InvalidationKind::Text
4379 | InvalidationKind::Visibility
4380 | InvalidationKind::Ordering
4381 ) {
4382 continue;
4383 }
4384 match request.target {
4385 InvalidationTarget::Widget(widget_id) => {
4386 subtree_roots.insert(widget_id);
4387 }
4388 InvalidationTarget::Window(_) | InvalidationTarget::Surface(_) => {
4389 force_all = true;
4390 }
4391 }
4392 }
4393
4394 if force_all || subtree_roots.is_empty() {
4395 return Rc::new(MeasureScope::force_all());
4396 }
4397
4398 let mut dirty: HashSet<WidgetId> = HashSet::new();
4399 for widget_id in &subtree_roots {
4400 if !self.graph.extend_ancestors(*widget_id, &mut dirty) {
4401 return Rc::new(MeasureScope::force_all());
4402 }
4403 }
4404
4405 Rc::new(MeasureScope::scoped(dirty, subtree_roots))
4406 }
4407
4408 fn run_measure_arrange_pass(
4409 &mut self,
4410 invalidations: &[InvalidationRequest],
4411 text_system: Arc<TextSystem>,
4412 font_registry: Arc<FontRegistry>,
4413 image_registry: Arc<ImageRegistry>,
4414 ) -> Vec<InvalidationRequest> {
4415 let constraints = self.measure_constraints();
4416 let scope = self.build_measure_scope(invalidations);
4417 let mut measure_ctx = MeasureCtx::new_scoped_at(
4418 self.id,
4419 self.root.id(),
4420 self.root.bounds(),
4421 self.current_dpi_info(),
4422 text_system,
4423 font_registry,
4424 image_registry,
4425 scope,
4426 self.last_tick_time,
4427 );
4428 let measured_root = if self.schedule.measure || self.viewport.is_none() {
4429 self.root.measure(&mut measure_ctx, constraints)
4430 } else {
4431 self.root.measured_size()
4432 };
4433 let viewport = constraints.clamp(measured_root);
4434
4435 let mut arrange_ctx = ArrangeCtx::new_at(
4436 self.id,
4437 self.root.id(),
4438 self.current_dpi_info(),
4439 self.last_tick_time,
4440 );
4441 self.root.arrange(
4442 &mut arrange_ctx,
4443 Rect::from_origin_size(Point::ZERO, viewport),
4444 );
4445 self.viewport = Some(viewport);
4446 self.schedule.measure = false;
4447 self.schedule.arrange = false;
4448 self.schedule.hit_test = false;
4449 self.refresh_graph();
4450
4451 let mut invalidations = measure_ctx.take_invalidations();
4452 self.apply_wake_requests(measure_ctx.take_wake_requests());
4453 invalidations.extend(arrange_ctx.take_invalidations());
4454 self.apply_wake_requests(arrange_ctx.take_wake_requests());
4455 invalidations
4456 }
4457
4458 fn refresh_graph(&mut self) {
4459 self.graph = WidgetGraph::rebuild(
4460 &self.root,
4461 self.focus.focused_widget,
4462 &self.last_paint_bounds_by_widget,
4463 );
4464 let overlay_focus = self.overlay_manager.sync(
4465 self.graph.overlay_snapshots(),
4466 &self.graph,
4467 self.focus.focused_widget,
4468 );
4469 if overlay_focus.is_some() {
4470 self.pending_overlay_focus = overlay_focus;
4471 }
4472 self.prune_runtime_state();
4473 self.schedule.hit_test = false;
4474 }
4475
4476 fn filter_modal_semantics(&self, mut nodes: Vec<SemanticsNode>) -> Vec<SemanticsNode> {
4477 let Some(modal) = self.overlay_manager.active_modal() else {
4478 return nodes;
4479 };
4480
4481 let modal_subtree = self
4482 .graph
4483 .subtree_ids(modal)
4484 .into_iter()
4485 .collect::<HashSet<_>>();
4486 let mut allowed = modal_subtree.clone();
4487 let mut ancestor = self.graph.node(modal).and_then(|node| node.parent);
4488 while let Some(widget_id) = ancestor {
4489 allowed.insert(widget_id);
4490 ancestor = self.graph.node(widget_id).and_then(|node| node.parent);
4491 }
4492
4493 let parents = nodes
4494 .iter()
4495 .map(|node| (node.id, node.parent))
4496 .collect::<HashMap<_, _>>();
4497 let belongs_to_modal = |node: &SemanticsNode| {
4498 if allowed.contains(&node.id) {
4499 return true;
4500 }
4501 let mut current = node.parent;
4502 let mut visited = HashSet::new();
4503 while let Some(parent) = current {
4504 if !visited.insert(parent) {
4505 break;
4506 }
4507 if modal_subtree.contains(&parent) {
4508 return true;
4509 }
4510 current = parents.get(&parent).copied().flatten();
4511 }
4512 false
4513 };
4514 nodes.retain(belongs_to_modal);
4515 if let Some(node) = nodes.iter_mut().find(|node| node.id == modal) {
4516 node.state.modal = true;
4517 }
4518 nodes
4519 }
4520
4521 fn sync_scene_stack_metadata(&self, scene: &mut Scene) {
4522 scene.visit_layers_mut(&mut |layer| {
4523 if let Some(node) = self.graph.node(layer.widget_id()) {
4524 layer.descriptor.stack_host = node.stack_host;
4525 layer.descriptor.stack_order = node.stack_surface_order;
4526 layer.descriptor.transient_owner_surface = node.transient_owner_surface;
4527 layer.descriptor.is_stack_surface = node.is_stack_surface;
4528 layer.descriptor.hit_test = node.hit_test;
4529 }
4530 });
4531 scene.reorder_stack_surfaces();
4532 }
4533
4534 fn prune_runtime_state(&mut self) {
4535 self.pointer_capture
4536 .retain(|_, widget_id| self.graph.contains(*widget_id));
4537 if self
4538 .active_drag
4539 .as_ref()
4540 .is_some_and(|drag| !self.graph.contains(drag.source))
4541 {
4542 self.active_drag = None;
4543 }
4544 self.scheduled_timers
4545 .retain(|timer| self.graph.contains(timer.target));
4546 self.delivering_timers
4547 .retain(|_, widget_id| self.graph.contains(*widget_id));
4548 self.async_wake_targets
4549 .retain(|_, widget_id| self.graph.contains(*widget_id));
4550 self.pending_async_wakeups
4551 .retain(|token| self.async_wake_targets.contains_key(token));
4552 self.requested_animation_frames
4553 .retain(|widget_id| self.graph.contains(*widget_id));
4554 self.delivering_animation_frames
4555 .retain(|widget_id| self.graph.contains(*widget_id));
4556 if self.requested_animation_frames.is_empty() && self.delivering_animation_frames.is_empty()
4557 {
4558 self.last_animation_frame_time = None;
4559 }
4560
4561 if self
4562 .focus
4563 .focused_widget
4564 .is_some_and(|widget_id| !self.graph.contains(widget_id))
4565 {
4566 self.focus.focused_widget = None;
4567 self.focused_semantics = None;
4568 }
4569 }
4570
4571 fn measure_constraints(&self) -> Constraints {
4572 self.viewport_hint
4573 .map(Constraints::tight)
4574 .unwrap_or(Constraints::UNBOUNDED)
4575 }
4576
4577 fn dpi_info_for_viewport(&self, viewport: Size) -> DpiInfo {
4578 DpiInfo::new(
4579 self.scale_factor,
4580 self.raw_dpi,
4581 viewport,
4582 scale_viewport_to_surface_size(viewport, self.scale_factor),
4583 )
4584 .with_safe_area(self.safe_area)
4585 }
4586
4587 fn current_dpi_info(&self) -> DpiInfo {
4588 let viewport = self.viewport.or(self.viewport_hint).unwrap_or(Size::ZERO);
4589 self.dpi_info_for_viewport(viewport)
4590 }
4591
4592 fn clear_inspector_history(&mut self) {
4593 self.event_route_history.clear();
4594 self.reactive_invalidation_history.clear();
4595 self.command_dispatch_history.clear();
4596 self.invalidation_history.clear();
4597 self.widget_rebuild_history.clear();
4598 }
4599
4600 fn capture_inspector_diagnostics(&mut self, diagnostics: &RenderDiagnostics) {
4601 if !self.inspector_tracing_enabled {
4602 return;
4603 }
4604
4605 extend_inspector_history(
4606 &mut self.reactive_invalidation_history,
4607 diagnostics.reactive_invalidations.iter().cloned(),
4608 );
4609 extend_inspector_history(
4610 &mut self.command_dispatch_history,
4611 diagnostics.command_dispatches.iter().cloned(),
4612 );
4613 extend_inspector_history(
4614 &mut self.invalidation_history,
4615 diagnostics.invalidations.iter().cloned(),
4616 );
4617 extend_inspector_history(
4618 &mut self.widget_rebuild_history,
4619 diagnostics.widget_rebuilds.iter().cloned(),
4620 );
4621 self.last_render_diagnostics = diagnostics.clone();
4622 }
4623
4624 fn scheduler_snapshot(&self) -> SchedulerInspectorSnapshot {
4625 let mut timers = self
4626 .scheduled_timers
4627 .iter()
4628 .map(|timer| TimerInspectorSnapshot {
4629 token: timer.token,
4630 target: timer.target,
4631 deadline: timer.deadline,
4632 delivering: self.delivering_timers.contains_key(&timer.token),
4633 })
4634 .collect::<Vec<_>>();
4635 for (&token, &target) in &self.delivering_timers {
4636 if timers.iter().all(|timer| timer.token != token) {
4637 timers.push(TimerInspectorSnapshot {
4638 token,
4639 target,
4640 deadline: self.last_tick_time,
4641 delivering: true,
4642 });
4643 }
4644 }
4645 timers.sort_by(|left, right| left.deadline.total_cmp(&right.deadline));
4646
4647 let mut async_tasks = self
4648 .async_wake_targets
4649 .iter()
4650 .map(|(&token, &target)| AsyncTaskInspectorSnapshot {
4651 token,
4652 target,
4653 pending_wake: self.pending_async_wakeups.contains(&token),
4654 })
4655 .collect::<Vec<_>>();
4656 async_tasks.sort_by_key(|task| task.token.get());
4657
4658 SchedulerInspectorSnapshot {
4659 timers,
4660 async_tasks,
4661 requested_animation_frames: self.requested_animation_frames.iter().copied().collect(),
4662 delivering_animation_frames: self.delivering_animation_frames.iter().copied().collect(),
4663 last_animation_frame_time: self.last_animation_frame_time,
4664 }
4665 }
4666
4667 fn inspector_snapshot(&self) -> WindowInspectorSnapshot {
4668 let mut widget_diagnostics = Vec::new();
4669 self.root.collect_diagnostics(&mut widget_diagnostics);
4670 WindowInspectorSnapshot {
4671 window_id: self.id,
4672 title: self.title.clone(),
4673 tracing_enabled: self.inspector_tracing_enabled,
4674 focus_state: self.focus,
4675 schedule: self.schedule,
4676 semantics: self.last_semantics.clone(),
4677 widget_graph: self.graph.snapshot(),
4678 overlays: self.overlay_manager.snapshot(),
4679 scheduler: self.scheduler_snapshot(),
4680 widget_diagnostics,
4681 last_render_diagnostics: self.last_render_diagnostics.clone(),
4682 history: InspectorHistorySnapshot {
4683 event_routes: self.event_route_history.iter().cloned().collect(),
4684 reactive_invalidations: self
4685 .reactive_invalidation_history
4686 .iter()
4687 .cloned()
4688 .collect(),
4689 command_dispatches: self.command_dispatch_history.iter().cloned().collect(),
4690 invalidations: self.invalidation_history.iter().cloned().collect(),
4691 widget_rebuilds: self.widget_rebuild_history.iter().cloned().collect(),
4692 },
4693 scene: self.last_frame.as_ref().map(|frame| {
4694 SceneStatistics::from_frame_with_mode(
4695 frame,
4696 self.graph.nodes.len(),
4697 window_scene_statistics_detail_mode(self.id),
4698 )
4699 }),
4700 }
4701 }
4702}
4703
4704impl Drop for WindowState {
4705 fn drop(&mut self) {
4706 reactive::unregister_window(self.id);
4707 diagnostics::clear_widget_rebuilds(self.id);
4708 }
4709}
4710
4711fn normalize_scale_factor(scale_factor: f32) -> f32 {
4712 if scale_factor.is_finite() && scale_factor > 0.0 {
4713 scale_factor
4714 } else {
4715 1.0
4716 }
4717}
4718
4719fn scale_viewport_to_surface_size(viewport: Size, scale_factor: f32) -> Size {
4720 if viewport.is_empty() {
4721 return Size::ZERO;
4722 }
4723
4724 let scale_factor = normalize_scale_factor(scale_factor);
4725 Size::new(
4726 (viewport.width * scale_factor).round().max(1.0),
4727 (viewport.height * scale_factor).round().max(1.0),
4728 )
4729}
4730
4731impl WindowState {
4732 fn assemble_semantics_tree(&mut self, nodes: Vec<SemanticsNode>) -> Vec<SemanticsNode> {
4733 let semantic_ids: HashSet<_> = nodes.iter().map(|node| node.id).collect();
4734 if self
4735 .focused_semantics
4736 .is_some_and(|focused| !semantic_ids.contains(&focused))
4737 {
4738 self.focused_semantics = self.focus.focused_widget;
4739 }
4740
4741 nodes
4742 .into_iter()
4743 .map(|mut node| {
4744 node.parent = self.resolve_semantics_parent(&semantic_ids, node.id, node.parent);
4745 node.state.focused |= Some(node.id) == self.focused_semantics;
4746 node
4747 })
4748 .collect()
4749 }
4750
4751 fn resolve_semantics_parent(
4752 &self,
4753 semantic_ids: &HashSet<WidgetId>,
4754 widget_id: WidgetId,
4755 explicit_parent: Option<WidgetId>,
4756 ) -> Option<WidgetId> {
4757 if let Some(parent) =
4758 explicit_parent.filter(|parent| *parent != widget_id && semantic_ids.contains(parent))
4759 {
4760 return Some(parent);
4761 }
4762
4763 let mut current = self.graph.node(widget_id).and_then(|node| node.parent);
4764 while let Some(candidate) = current {
4765 if semantic_ids.contains(&candidate) {
4766 return Some(candidate);
4767 }
4768 current = self.graph.node(candidate).and_then(|node| node.parent);
4769 }
4770 None
4771 }
4772}
4773
4774#[derive(Default)]
4775struct WidgetGraph {
4776 root: WidgetId,
4777 nodes: HashMap<WidgetId, WidgetNodeSnapshot>,
4778 order: Vec<WidgetId>,
4779 host_surface_order: HashMap<WidgetId, Vec<WidgetId>>,
4780 host_order_policy: HashMap<WidgetId, StackOrderPolicy>,
4781 overlay_options: HashMap<WidgetId, OverlayOptions>,
4782 overlay_parents: HashMap<WidgetId, Option<WidgetId>>,
4783 overlay_surfaces: HashMap<WidgetId, Vec<WidgetId>>,
4784}
4785
4786#[derive(Clone, Copy)]
4787struct GraphCollectContext {
4788 stack_host: WidgetId,
4789 stack_surface: WidgetId,
4790 overlay_owner: Option<WidgetId>,
4791}
4792
4793impl WidgetGraph {
4794 fn empty(root: WidgetId) -> Self {
4795 Self {
4796 root,
4797 nodes: HashMap::new(),
4798 order: Vec::new(),
4799 host_surface_order: HashMap::new(),
4800 host_order_policy: HashMap::new(),
4801 overlay_options: HashMap::new(),
4802 overlay_parents: HashMap::new(),
4803 overlay_surfaces: HashMap::new(),
4804 }
4805 }
4806
4807 fn rebuild(
4808 root: &WidgetPod,
4809 focused_widget: Option<WidgetId>,
4810 paint_bounds_by_widget: &HashMap<WidgetId, Rect>,
4811 ) -> Self {
4812 let mut graph = Self::empty(root.id());
4813 graph.collect(
4814 root,
4815 None,
4816 focused_widget,
4817 paint_bounds_by_widget,
4818 GraphCollectContext {
4819 stack_host: root.id(),
4820 stack_surface: root.id(),
4821 overlay_owner: None,
4822 },
4823 );
4824 graph.recompute_stack_surface_order();
4825 graph
4826 }
4827
4828 fn recompute_stack_surface_order(&mut self) {
4829 let mut position_by_surface = HashMap::<(WidgetId, WidgetId), usize>::new();
4830 for (host, surfaces) in &self.host_surface_order {
4831 for (index, surface) in surfaces.iter().copied().enumerate() {
4832 position_by_surface.insert((*host, surface), index);
4833 }
4834 }
4835
4836 for node in self.nodes.values_mut() {
4837 if let Some(order) = position_by_surface.get(&(node.stack_host, node.stack_surface)) {
4838 node.stack_surface_order = *order;
4839 }
4840 }
4841 }
4842
4843 fn update_paint_bounds_from_snapshot(
4844 &mut self,
4845 paint_bounds_by_widget: &HashMap<WidgetId, Rect>,
4846 ) {
4847 for node in self.nodes.values_mut() {
4848 node.geometry.paint_bounds = paint_bounds_by_widget
4849 .get(&node.id)
4850 .copied()
4851 .unwrap_or(node.geometry.layout_bounds);
4852 }
4853 }
4854
4855 fn set_focused_widget(&mut self, focused_widget: Option<WidgetId>) {
4856 for node in self.nodes.values_mut() {
4857 node.focused = Some(node.id) == focused_widget;
4858 }
4859 }
4860
4861 fn is_empty(&self) -> bool {
4862 self.nodes.is_empty()
4863 }
4864
4865 fn contains(&self, widget_id: WidgetId) -> bool {
4866 self.nodes.contains_key(&widget_id)
4867 }
4868
4869 fn node(&self, widget_id: WidgetId) -> Option<&WidgetNodeSnapshot> {
4870 self.nodes.get(&widget_id)
4871 }
4872
4873 fn snapshot(&self) -> WidgetGraphSnapshot {
4874 let mut stack_hosts = self
4875 .host_order_policy
4876 .iter()
4877 .map(|(host, order_policy)| StackHostSnapshot {
4878 host: *host,
4879 order_policy: *order_policy,
4880 surfaces: self
4881 .host_surface_order
4882 .get(host)
4883 .cloned()
4884 .unwrap_or_default(),
4885 })
4886 .collect::<Vec<_>>();
4887 stack_hosts.sort_by_key(|host| host.host.get());
4888
4889 WidgetGraphSnapshot {
4890 root: self.root,
4891 nodes: self
4892 .order
4893 .iter()
4894 .filter_map(|widget_id| self.nodes.get(widget_id).cloned())
4895 .collect(),
4896 stack_hosts,
4897 }
4898 }
4899
4900 fn hit_test(&self, point: Point) -> Option<WidgetId> {
4901 self.hit_test_node(self.root, point)
4902 }
4903
4904 fn hit_test_within(&self, widget_id: WidgetId, point: Point) -> Option<WidgetId> {
4905 self.hit_test_node(widget_id, point)
4906 }
4907
4908 fn path_to(&self, target: WidgetId) -> Option<Vec<WidgetId>> {
4909 let mut path = Vec::new();
4910 let mut current = Some(target);
4911
4912 while let Some(widget_id) = current {
4913 let node = self.node(widget_id)?;
4914 path.push(widget_id);
4915 current = node.parent;
4916 }
4917
4918 path.reverse();
4919 Some(path)
4920 }
4921
4922 fn depth(&self, target: WidgetId) -> Option<usize> {
4923 let mut depth = 0usize;
4924 let mut current = Some(target);
4925 while let Some(widget_id) = current {
4926 let node = self.node(widget_id)?;
4927 depth += 1;
4928 current = node.parent;
4929 }
4930 Some(depth)
4931 }
4932
4933 fn is_ancestor_of(&self, ancestor: WidgetId, target: WidgetId) -> bool {
4934 let mut current = self.node(target).and_then(|node| node.parent);
4935 while let Some(widget_id) = current {
4936 if widget_id == ancestor {
4937 return true;
4938 }
4939 current = self.node(widget_id).and_then(|node| node.parent);
4940 }
4941 false
4942 }
4943
4944 fn extend_ancestors(&self, target: WidgetId, ancestors: &mut HashSet<WidgetId>) -> bool {
4945 let mut current = Some(target);
4946 while let Some(widget_id) = current {
4947 let Some(node) = self.node(widget_id) else {
4948 return false;
4949 };
4950 ancestors.insert(widget_id);
4951 current = node.parent;
4952 }
4953 true
4954 }
4955
4956 fn subtree_ids(&self, root: WidgetId) -> Vec<WidgetId> {
4957 let mut subtree = Vec::new();
4958 let mut pending = vec![root];
4959 while let Some(widget_id) = pending.pop() {
4960 let Some(node) = self.node(widget_id) else {
4961 continue;
4962 };
4963 subtree.push(widget_id);
4964 pending.extend(node.children.iter().copied());
4965 }
4966 subtree
4967 }
4968
4969 fn nearest_paint_boundary_ancestor_or_root(&self, widget_id: WidgetId) -> WidgetId {
4970 let mut current = Some(widget_id);
4971 while let Some(candidate) = current {
4972 let Some(node) = self.node(candidate) else {
4973 break;
4974 };
4975 if node.paint_boundary == PaintBoundaryMode::Explicit {
4976 return candidate;
4977 }
4978 current = node.parent;
4979 }
4980 self.root
4981 }
4982
4983 fn next_focusable(&self, current: Option<WidgetId>, backwards: bool) -> Option<WidgetId> {
4984 let focusable: Vec<_> = self
4985 .order
4986 .iter()
4987 .copied()
4988 .filter(|widget_id| self.node(*widget_id).is_some_and(|node| node.accepts_focus))
4989 .collect();
4990
4991 if focusable.is_empty() {
4992 return None;
4993 }
4994
4995 let fallback = if backwards {
4996 focusable.last().copied()
4997 } else {
4998 focusable.first().copied()
4999 };
5000
5001 let Some(current) = current else {
5002 return fallback;
5003 };
5004
5005 let Some(index) = focusable.iter().position(|widget_id| *widget_id == current) else {
5006 return fallback;
5007 };
5008
5009 if backwards {
5010 Some(focusable[(index + focusable.len() - 1) % focusable.len()])
5011 } else {
5012 Some(focusable[(index + 1) % focusable.len()])
5013 }
5014 }
5015
5016 fn first_focusable_within(
5017 &self,
5018 overlay_owner: WidgetId,
5019 include_owner: bool,
5020 ) -> Option<WidgetId> {
5021 self.order.iter().copied().find(|candidate| {
5022 self.node(*candidate).is_some_and(|node| node.accepts_focus)
5023 && (include_owner && *candidate == overlay_owner
5024 || self.is_ancestor_of(overlay_owner, *candidate))
5025 })
5026 }
5027
5028 fn next_focusable_within(
5029 &self,
5030 scope: WidgetId,
5031 current: Option<WidgetId>,
5032 backwards: bool,
5033 ) -> Option<WidgetId> {
5034 let focusable = self
5035 .order
5036 .iter()
5037 .copied()
5038 .filter(|candidate| {
5039 self.node(*candidate).is_some_and(|node| node.accepts_focus)
5040 && (*candidate == scope || self.is_ancestor_of(scope, *candidate))
5041 })
5042 .collect::<Vec<_>>();
5043 if focusable.is_empty() {
5044 return None;
5045 }
5046 let fallback = if backwards {
5047 focusable.last().copied()
5048 } else {
5049 focusable.first().copied()
5050 };
5051 let Some(current) = current else {
5052 return fallback;
5053 };
5054 let Some(index) = focusable.iter().position(|candidate| *candidate == current) else {
5055 return fallback;
5056 };
5057 if backwards {
5058 Some(focusable[(index + focusable.len() - 1) % focusable.len()])
5059 } else {
5060 Some(focusable[(index + 1) % focusable.len()])
5061 }
5062 }
5063
5064 fn overlay_snapshots(&self) -> Vec<OverlaySnapshot> {
5065 self.order
5066 .iter()
5067 .copied()
5068 .filter_map(|owner| {
5069 let options = self.overlay_options.get(&owner).copied()?;
5070 Some(OverlaySnapshot {
5071 owner,
5072 parent: self.overlay_parents.get(&owner).copied().flatten(),
5073 surfaces: self
5074 .overlay_surfaces
5075 .get(&owner)
5076 .cloned()
5077 .unwrap_or_default(),
5078 options,
5079 order: 0,
5080 })
5081 })
5082 .enumerate()
5083 .map(|(order, mut snapshot)| {
5084 snapshot.order = order;
5085 snapshot
5086 })
5087 .collect()
5088 }
5089
5090 fn collect(
5091 &mut self,
5092 pod: &WidgetPod,
5093 parent: Option<WidgetId>,
5094 focused_widget: Option<WidgetId>,
5095 paint_bounds_by_widget: &HashMap<WidgetId, Rect>,
5096 context: GraphCollectContext,
5097 ) {
5098 let id = pod.id();
5099 self.order.push(id);
5100
5101 let overlay_options = pod.current_overlay_options();
5102 let is_overlay_owner = overlay_options.is_some();
5103 let overlay_owner = if is_overlay_owner {
5104 Some(id)
5105 } else {
5106 context.overlay_owner
5107 };
5108 if let Some(options) = overlay_options {
5109 self.overlay_options.insert(id, options);
5110 self.overlay_parents.insert(id, context.overlay_owner);
5111 }
5112
5113 let host_options = if id == self.root {
5114 Some(pod.current_stack_host_options().unwrap_or_default())
5115 } else {
5116 pod.current_stack_host_options()
5117 };
5118 let is_stack_host = host_options.is_some();
5119 let resolved_host = if is_stack_host {
5120 id
5121 } else {
5122 context.stack_host
5123 };
5124 let host_policy = host_options
5125 .map(|options| options.order_policy)
5126 .unwrap_or(StackOrderPolicy::Stable);
5127 if is_stack_host {
5128 self.host_order_policy.insert(resolved_host, host_policy);
5129 } else {
5130 self.host_order_policy
5131 .entry(resolved_host)
5132 .or_insert(StackOrderPolicy::Stable);
5133 }
5134 let resolved_policy = *self
5135 .host_order_policy
5136 .get(&resolved_host)
5137 .unwrap_or(&StackOrderPolicy::Stable);
5138
5139 let surface_options = pod.current_stack_surface_options();
5140 let emits_layer = pod.current_layer_options().emits_layer();
5141 let is_direct_child_of_host = parent == Some(resolved_host);
5142 let is_stack_surface = id != self.root
5143 && emits_layer
5144 && (surface_options.is_some() || is_direct_child_of_host);
5145 let hit_test = surface_options.is_none_or(|options| options.hit_test);
5146 let resolved_surface = if is_stack_surface {
5147 id
5148 } else {
5149 context.stack_surface
5150 };
5151 let transient_owner_surface = surface_options
5152 .filter(|options| emits_layer && options.transient && context.stack_surface != id)
5153 .map(|_| context.stack_surface);
5154 if is_stack_surface {
5155 let surfaces = self.host_surface_order.entry(resolved_host).or_default();
5156 if !surfaces.contains(&id) {
5157 surfaces.push(id);
5158 }
5159 }
5160 if is_stack_surface && let Some(owner) = overlay_owner {
5161 self.overlay_surfaces.entry(owner).or_default().push(id);
5162 }
5163 let stack_surface_order = self
5164 .host_surface_order
5165 .get(&resolved_host)
5166 .and_then(|surfaces| {
5167 surfaces
5168 .iter()
5169 .position(|surface| *surface == resolved_surface)
5170 })
5171 .unwrap_or(0);
5172
5173 let children = {
5174 let mut visitor = CollectChildrenVisitor {
5175 graph: self,
5176 parent: id,
5177 focused_widget,
5178 paint_bounds_by_widget,
5179 context: GraphCollectContext {
5180 stack_host: resolved_host,
5181 stack_surface: resolved_surface,
5182 overlay_owner,
5183 },
5184 children: Vec::new(),
5185 };
5186 pod.visit_children(&mut visitor);
5187 visitor.children
5188 };
5189
5190 let layout_bounds = pod.bounds();
5191 let input_bounds = layout_bounds;
5192 let paint_bounds = paint_bounds_by_widget
5193 .get(&id)
5194 .copied()
5195 .unwrap_or(layout_bounds);
5196
5197 self.nodes.insert(
5198 id,
5199 WidgetNodeSnapshot {
5200 id,
5201 widget_name: pod.debug_name(),
5202 parent,
5203 children,
5204 measured_size: pod.measured_size(),
5205 geometry: WidgetGeometrySnapshot::new(layout_bounds, input_bounds, paint_bounds),
5206 bounds: layout_bounds,
5207 paint_boundary: pod.current_paint_boundary_mode(),
5208 stack_host: resolved_host,
5209 stack_surface: resolved_surface,
5210 stack_surface_order,
5211 transient_owner_surface,
5212 overlay_owner,
5213 is_overlay_owner,
5214 is_stack_host,
5215 is_stack_surface,
5216 hit_test,
5217 stack_order_policy: resolved_policy,
5218 accepts_focus: pod.accepts_focus(),
5219 focused: Some(id) == focused_widget,
5220 },
5221 );
5222 }
5223
5224 fn hit_test_node(&self, widget_id: WidgetId, point: Point) -> Option<WidgetId> {
5225 let node = self.node(widget_id)?;
5226 if !node.hit_test || !node.geometry.input_bounds.contains(point) {
5227 return None;
5228 }
5229
5230 if node.is_stack_host {
5231 let mut tested_surfaces = HashSet::new();
5232 if let Some(ordered_surfaces) = self.host_surface_order.get(&node.id) {
5233 for surface_id in ordered_surfaces.iter().rev().copied() {
5234 if surface_id == widget_id {
5235 continue;
5236 }
5237 tested_surfaces.insert(surface_id);
5238 if let Some(hit) = self.hit_test_node(surface_id, point) {
5239 return Some(hit);
5240 }
5241 }
5242 }
5243
5244 for child_id in node.children.iter().rev() {
5245 if self.node(*child_id).is_some_and(|child| {
5246 child.is_stack_surface || tested_surfaces.contains(child_id)
5247 }) {
5248 continue;
5249 }
5250 if let Some(hit) = self.hit_test_node(*child_id, point) {
5251 return Some(hit);
5252 }
5253 }
5254
5255 return Some(widget_id);
5256 }
5257
5258 for child_id in node.children.iter().rev() {
5259 if let Some(hit) = self.hit_test_node(*child_id, point) {
5260 return Some(hit);
5261 }
5262 }
5263
5264 Some(widget_id)
5265 }
5266}
5267
5268struct CollectChildrenVisitor<'a> {
5269 graph: &'a mut WidgetGraph,
5270 parent: WidgetId,
5271 focused_widget: Option<WidgetId>,
5272 paint_bounds_by_widget: &'a HashMap<WidgetId, Rect>,
5273 context: GraphCollectContext,
5274 children: Vec<WidgetId>,
5275}
5276
5277impl WidgetPodVisitor for CollectChildrenVisitor<'_> {
5278 fn visit(&mut self, child: &WidgetPod) {
5279 self.children.push(child.id());
5280 self.graph.collect(
5281 child,
5282 Some(self.parent),
5283 self.focused_widget,
5284 self.paint_bounds_by_widget,
5285 self.context,
5286 );
5287 }
5288}
5289
5290struct EventRouteResult {
5291 path: Vec<WidgetId>,
5292 effects: EventEffects,
5293 focus_request: Option<FocusRequest>,
5294 handled: bool,
5295}
5296
5297#[derive(Default)]
5298struct HoverTransitionResult {
5299 effects: EventEffects,
5300 focus_request: Option<FocusRequest>,
5301 skip_primary_route: bool,
5302}
5303
5304#[derive(Default)]
5305struct EventEffects {
5306 invalidations: Vec<InvalidationRequest>,
5307 wake_requests: Vec<WakeRequest>,
5308 pointer_capture_requests: Vec<PointerCaptureRequest>,
5309 drag_requests: Vec<DragRequest>,
5310 drop_acceptances: Vec<DropAcceptanceRequest>,
5311 posted_events: Vec<widget::PostedEventRequest>,
5312 posted_commands: Vec<widget::PostedCommandRequest>,
5313}
5314
5315impl EventEffects {
5316 fn extend(&mut self, dispatch: widget::EventDispatch) {
5317 self.invalidations.extend(dispatch.invalidations);
5318 self.wake_requests.extend(dispatch.wake_requests);
5319 self.pointer_capture_requests
5320 .extend(dispatch.pointer_capture_requests);
5321 self.drag_requests.extend(dispatch.drag_requests);
5322 self.drop_acceptances.extend(dispatch.drop_acceptances);
5323 self.posted_events.extend(dispatch.posted_events);
5324 self.posted_commands.extend(dispatch.posted_commands);
5325 }
5326
5327 fn merge(&mut self, effects: EventEffects) {
5328 self.invalidations.extend(effects.invalidations);
5329 self.wake_requests.extend(effects.wake_requests);
5330 self.pointer_capture_requests
5331 .extend(effects.pointer_capture_requests);
5332 self.drag_requests.extend(effects.drag_requests);
5333 self.drop_acceptances.extend(effects.drop_acceptances);
5334 self.posted_events.extend(effects.posted_events);
5335 self.posted_commands.extend(effects.posted_commands);
5336 }
5337}
5338
5339fn empty_dispatch() -> widget::EventDispatch {
5340 widget::EventDispatch {
5341 handled: false,
5342 invalidations: Vec::new(),
5343 focus_request: None,
5344 wake_requests: Vec::new(),
5345 pointer_capture_requests: Vec::new(),
5346 drag_requests: Vec::new(),
5347 drop_acceptances: Vec::new(),
5348 posted_events: Vec::new(),
5349 posted_commands: Vec::new(),
5350 }
5351}
5352
5353const MAX_PENDING_TRACE_SAMPLES: usize = 512;
5354const MAX_INSPECTOR_HISTORY_SAMPLES: usize = 256;
5355
5356fn push_trace<T>(samples: &mut Vec<T>, sample: T) {
5357 if samples.len() == MAX_PENDING_TRACE_SAMPLES {
5358 samples.remove(0);
5359 }
5360 samples.push(sample);
5361}
5362
5363fn extend_traces<T>(samples: &mut Vec<T>, additions: impl IntoIterator<Item = T>) {
5364 for sample in additions {
5365 push_trace(samples, sample);
5366 }
5367}
5368
5369fn push_inspector_history<T>(samples: &mut VecDeque<T>, sample: T) {
5370 if samples.len() == MAX_INSPECTOR_HISTORY_SAMPLES {
5371 samples.pop_front();
5372 }
5373 samples.push_back(sample);
5374}
5375
5376fn extend_inspector_history<T>(samples: &mut VecDeque<T>, additions: impl IntoIterator<Item = T>) {
5377 for sample in additions {
5378 push_inspector_history(samples, sample);
5379 }
5380}
5381
5382fn command_sample(
5383 command: &QueuedCommand,
5384 handlers: Vec<String>,
5385 handled: bool,
5386 delivered: bool,
5387) -> CommandDispatchSample {
5388 CommandDispatchSample {
5389 sequence: command.sequence,
5390 name: command.key.name.to_string(),
5391 payload_type: command.key.payload_type_name.to_string(),
5392 target: command.target,
5393 delivery: command.delivery,
5394 handlers,
5395 handled,
5396 delivered,
5397 }
5398}
5399
5400fn event_trace_source(event: &Event) -> String {
5401 let kind = match event {
5402 Event::Pointer(event) => format!("pointer:{:?}", event.kind),
5403 Event::Drag(event) => format!("drag:{:?}", event.kind),
5404 Event::Keyboard(_) => "keyboard".to_string(),
5405 Event::Ime(_) => "ime".to_string(),
5406 Event::Semantics(_) => "semantics".to_string(),
5407 Event::Wake(event) => format!("wake:{event:?}"),
5408 Event::Window(event) => format!("window:{event:?}"),
5409 Event::Custom(event) => format!("custom:{}", event.kind),
5410 };
5411 format!("event:{kind}")
5412}
5413
5414fn inspector_event_kind(event: &Event) -> &'static str {
5415 match event {
5416 Event::Pointer(_) => "pointer",
5417 Event::Drag(_) => "drag",
5418 Event::Keyboard(_) => "keyboard",
5419 Event::Ime(_) => "ime",
5420 Event::Semantics(_) => "semantics",
5421 Event::Wake(_) => "wake",
5422 Event::Window(_) => "window",
5423 Event::Custom(_) => "custom",
5424 }
5425}
5426
5427fn nearest_drop_acceptance(
5428 acceptances: &[DropAcceptanceRequest],
5429 path: &[WidgetId],
5430) -> Option<DropAcceptanceRequest> {
5431 acceptances
5432 .iter()
5433 .filter_map(|acceptance| {
5434 path.iter()
5435 .position(|widget_id| *widget_id == acceptance.target)
5436 .map(|index| (index, *acceptance))
5437 })
5438 .max_by_key(|(index, _)| *index)
5439 .map(|(_, acceptance)| acceptance)
5440}
5441
5442fn collect_dirty_regions<F>(
5443 viewport: Size,
5444 invalidations: &[InvalidationRequest],
5445 repainted: bool,
5446 default_region_for: F,
5447) -> Vec<DirtyRegion>
5448where
5449 F: FnMut(&InvalidationRequest) -> Rect,
5450{
5451 let viewport_rect = Rect::from_origin_size(Point::ZERO, viewport);
5452 let mut default_region_for = default_region_for;
5453
5454 if invalidations.is_empty() {
5455 return if repainted {
5456 vec![DirtyRegion::new(viewport_rect, InvalidationKind::Paint)]
5457 } else {
5458 Vec::new()
5459 };
5460 }
5461 let mut dirty_regions: Vec<_> = invalidations
5462 .iter()
5463 .map(|request| {
5464 DirtyRegion::new(
5465 request
5466 .region
5467 .unwrap_or_else(|| default_region_for(request)),
5468 request.kind,
5469 )
5470 })
5471 .collect();
5472
5473 if repainted
5474 && dirty_regions
5475 .iter()
5476 .all(|region| region.kind != InvalidationKind::Paint)
5477 {
5478 dirty_regions.push(DirtyRegion::new(viewport_rect, InvalidationKind::Paint));
5479 }
5480
5481 dirty_regions
5482}
5483
5484fn collect_scene_layers(scene: &Scene) -> HashMap<WidgetId, SceneLayerDescriptor> {
5485 let mut layers = HashMap::new();
5486 scene.visit_layers(&mut |layer| {
5487 layers.insert(layer.widget_id(), layer.descriptor.clone());
5488 });
5489 layers
5490}
5491
5492fn retain_text_layouts_for_scene(text_system: &TextSystem, scene: &Scene) {
5493 text_system.retain_persistent_layouts(&active_text_layout_handles(scene));
5494}
5495
5496fn active_text_layout_handles(scene: &Scene) -> HashSet<TextLayoutHandle> {
5497 let mut handles = HashSet::new();
5498 scene.visit_commands(&mut |command| match command {
5499 SceneCommand::DrawShapedText(text) => {
5500 handles.insert(text.layout_handle);
5501 }
5502 SceneCommand::DrawShapedTextWindow(text) => {
5503 handles.insert(text.layout_handle);
5504 }
5505 _ => {}
5506 });
5507 handles
5508}
5509
5510fn resolve_snapshot_paint_boundary_or_root(
5511 snapshot: &WidgetGraphSnapshot,
5512 widget_id: WidgetId,
5513) -> WidgetId {
5514 let nodes = snapshot
5515 .nodes
5516 .iter()
5517 .map(|node| (node.id, node))
5518 .collect::<HashMap<_, _>>();
5519 let mut current = Some(widget_id);
5520 while let Some(candidate) = current {
5521 let Some(node) = nodes.get(&candidate) else {
5522 break;
5523 };
5524 if node.paint_boundary == PaintBoundaryMode::Explicit {
5525 return candidate;
5526 }
5527 current = node.parent;
5528 }
5529 snapshot.root
5530}
5531
5532#[derive(Debug, Clone, Copy, PartialEq, Eq)]
5533enum HitTestCompositionPhase {
5534 Normal,
5535 Overlay,
5536 Effect,
5537}
5538
5539fn scene_hit_test_for_phase(
5540 scene: &Scene,
5541 point: Point,
5542 target_phase: HitTestCompositionPhase,
5543 inherited_phase: HitTestCompositionPhase,
5544) -> Option<WidgetId> {
5545 for command in scene.commands().iter().rev() {
5546 let SceneCommand::Layer(layer) = command else {
5547 continue;
5548 };
5549
5550 let layer_phase = next_hit_test_phase(inherited_phase, layer.descriptor.composition_mode);
5551 if !layer.descriptor.paint_bounds.contains(point) {
5552 continue;
5553 }
5554 if !layer.descriptor.hit_test {
5555 continue;
5556 }
5557
5558 if let Some(hit) = scene_hit_test_for_phase(&layer.scene, point, target_phase, layer_phase)
5559 {
5560 return Some(hit);
5561 }
5562
5563 if layer_phase == target_phase {
5564 return Some(layer.widget_id());
5565 }
5566 }
5567
5568 None
5569}
5570
5571fn next_hit_test_phase(
5572 inherited_phase: HitTestCompositionPhase,
5573 composition_mode: LayerCompositionMode,
5574) -> HitTestCompositionPhase {
5575 match (inherited_phase, composition_mode) {
5576 (HitTestCompositionPhase::Effect, _) | (_, LayerCompositionMode::Effect) => {
5577 HitTestCompositionPhase::Effect
5578 }
5579 (HitTestCompositionPhase::Overlay, _) | (_, LayerCompositionMode::Overlay) => {
5580 HitTestCompositionPhase::Overlay
5581 }
5582 _ => HitTestCompositionPhase::Normal,
5583 }
5584}
5585
5586fn invalidation_to_layer_update_kind(kind: InvalidationKind) -> Option<SceneLayerUpdateKind> {
5587 match kind {
5588 InvalidationKind::Measure | InvalidationKind::Arrange | InvalidationKind::Transform => {
5589 Some(SceneLayerUpdateKind::Transform)
5590 }
5591 InvalidationKind::Ordering => Some(SceneLayerUpdateKind::Ordering),
5592 InvalidationKind::Clip => Some(SceneLayerUpdateKind::Clip),
5593 InvalidationKind::Effect => Some(SceneLayerUpdateKind::Effect),
5594 InvalidationKind::Visibility => Some(SceneLayerUpdateKind::Visibility),
5595 InvalidationKind::Paint | InvalidationKind::Text => Some(SceneLayerUpdateKind::Content),
5596 InvalidationKind::Resources => Some(SceneLayerUpdateKind::Resources),
5597 InvalidationKind::HitTest | InvalidationKind::Semantics => None,
5598 }
5599}
5600
5601fn merge_layer_update_kind(
5602 updates: &mut HashMap<WidgetId, SceneLayerUpdateKind>,
5603 widget_id: WidgetId,
5604 kind: SceneLayerUpdateKind,
5605) {
5606 updates
5607 .entry(widget_id)
5608 .and_modify(|current| {
5609 if layer_update_priority(kind) > layer_update_priority(*current) {
5610 *current = kind;
5611 }
5612 })
5613 .or_insert(kind);
5614}
5615
5616fn layer_update_priority(kind: SceneLayerUpdateKind) -> u8 {
5617 match kind {
5618 SceneLayerUpdateKind::Visibility => 0,
5619 SceneLayerUpdateKind::Ordering => 1,
5620 SceneLayerUpdateKind::Transform => 2,
5621 SceneLayerUpdateKind::Clip => 3,
5622 SceneLayerUpdateKind::Content => 4,
5623 SceneLayerUpdateKind::Effect => 5,
5624 SceneLayerUpdateKind::Resources => 6,
5625 }
5626}
5627
5628#[derive(Debug, Clone, PartialEq)]
5629pub struct RenderOutput {
5630 pub title: String,
5631 pub frame: SceneFrame,
5632 pub semantics: Vec<SemanticsNode>,
5633 pub ime_composition_rect: Option<Rect>,
5634 pub diagnostics: RenderDiagnostics,
5635}
5636
5637#[cfg(test)]
5638mod tests {
5639 use std::{
5640 cell::RefCell,
5641 collections::VecDeque,
5642 path::PathBuf,
5643 rc::Rc,
5644 sync::{
5645 Arc, Mutex,
5646 atomic::{AtomicUsize, Ordering},
5647 },
5648 };
5649
5650 use super::{
5651 Application, ArrangeCtx, Command, CommandController, CommandCtx, CommandKey, CommandTarget,
5652 EventCtx, EventPhase, EventRoutePhase, FocusScope, FocusScopeState, FocusState,
5653 FrameSchedule, LayerOptions, MeasureCtx, OVERLAY_DISMISS_REQUEST, OverlayDismissReason,
5654 OverlayFocusBehavior, OverlayKind, OverlayOptions, OverlayTraceKind, PaintBoundaryMode,
5655 PaintCtx, RenderOutput, Runtime, SceneStatisticsDetailMode, SemanticsCtx, SingleChild,
5656 StackSurfaceOptions, Widget, WidgetChildren, WidgetDiagnosticsCtx, WidgetGraphSnapshot,
5657 WidgetNodeSnapshot, WidgetPodMutVisitor, WidgetPodVisitor, WindowBuilder, WindowIcon,
5658 WindowRenderOptions, set_window_render_options, set_window_scene_statistics_detail_mode,
5659 window_render_options,
5660 };
5661 use sui_core::{
5662 AsyncWakeToken, Color, CustomEvent, DragEventKind, DragOutcome, DragPayload, DragScopeId,
5663 DragSessionId, DropEffect, Event, FontHandle, ImageHandle, InvalidationKind, KeyState,
5664 KeyboardEvent, Point, PointerButton, PointerButtons, PointerEvent, PointerEventKind,
5665 PointerKind, Rect, SemanticsAction, SemanticsActionRequest, SemanticsNode, SemanticsRole,
5666 SemanticsValue, Size, TimerToken, Vector, WakeEvent, WidgetId, WindowEvent,
5667 };
5668 use sui_layout::Constraints;
5669 use sui_reactive::Signal;
5670 use sui_scene::{
5671 LayerCompositionMode, LayerProperties, RegisteredExternalImage, RegisteredImage, Scene,
5672 SceneCommand, SceneLayerUpdateKind,
5673 };
5674 use sui_text::{PersistentTextLayout, RegisteredFont, TextStyle, TextSystem};
5675
5676 #[derive(Default)]
5677 struct Counters {
5678 paint: usize,
5679 semantics: usize,
5680 keyboard: usize,
5681 focus_changes: usize,
5682 }
5683
5684 struct FocusLeaf {
5685 counters: Rc<RefCell<Counters>>,
5686 }
5687
5688 struct WindowEventRecorder {
5689 events: Rc<RefCell<Vec<WindowEvent>>>,
5690 }
5691
5692 impl Widget for WindowEventRecorder {
5693 fn event(&mut self, _ctx: &mut EventCtx, event: &Event) {
5694 if let Event::Window(event) = event {
5695 self.events.borrow_mut().push(event.clone());
5696 }
5697 }
5698
5699 fn measure(&mut self, _ctx: &mut MeasureCtx, constraints: Constraints) -> Size {
5700 constraints.clamp(Size::new(120.0, 80.0))
5701 }
5702 }
5703
5704 const SYNTHETIC_ACTION_ID: WidgetId = WidgetId::new(u64::MAX - 1);
5705
5706 #[derive(Debug, Default)]
5707 struct SemanticActionState {
5708 actions: Vec<(WidgetId, SemanticsActionRequest)>,
5709 pointer_activations: usize,
5710 disabled: bool,
5711 expanded: bool,
5712 }
5713
5714 struct SyntheticSemanticActionLeaf {
5715 state: Rc<RefCell<SemanticActionState>>,
5716 }
5717
5718 struct UnfocusableSemanticLeaf;
5719
5720 impl Widget for UnfocusableSemanticLeaf {
5721 fn measure(&mut self, _ctx: &mut MeasureCtx, constraints: Constraints) -> Size {
5722 constraints.clamp(Size::new(120.0, 40.0))
5723 }
5724
5725 fn semantics(&self, ctx: &mut SemanticsCtx) {
5726 let mut node = SemanticsNode::new(ctx.widget_id(), SemanticsRole::Button, ctx.bounds());
5727 node.name = Some("unfocusable semantic node".to_string());
5728 node.actions = vec![SemanticsAction::Focus];
5729 ctx.push(node);
5730 }
5731 }
5732
5733 impl Widget for SyntheticSemanticActionLeaf {
5734 fn event(&mut self, ctx: &mut EventCtx, event: &Event) {
5735 match event {
5736 Event::Semantics(event) => {
5737 self.state
5738 .borrow_mut()
5739 .actions
5740 .push((event.target, event.action.clone()));
5741 if !matches!(
5742 event.action,
5743 SemanticsActionRequest::Activate
5744 | SemanticsActionRequest::Blur
5745 | SemanticsActionRequest::Expand
5746 | SemanticsActionRequest::Collapse
5747 ) {
5748 ctx.set_handled();
5749 }
5750 }
5751 Event::Pointer(pointer) if pointer.kind == PointerEventKind::Up => {
5752 let mut state = self.state.borrow_mut();
5753 state.pointer_activations += 1;
5754 state.expanded = !state.expanded;
5755 ctx.set_handled();
5756 }
5757 _ => {}
5758 }
5759 }
5760
5761 fn measure(&mut self, _ctx: &mut MeasureCtx, constraints: Constraints) -> Size {
5762 constraints.clamp(Size::new(160.0, 64.0))
5763 }
5764
5765 fn paint(&self, ctx: &mut PaintCtx) {
5766 ctx.fill_bounds(Color::rgba(0.16, 0.24, 0.34, 1.0));
5767 }
5768
5769 fn semantics(&self, ctx: &mut SemanticsCtx) {
5770 let mut owner = SemanticsNode::new(
5771 ctx.widget_id(),
5772 SemanticsRole::GenericContainer,
5773 ctx.bounds(),
5774 );
5775 owner.name = Some("semantic action owner".to_string());
5776 ctx.push(owner);
5777
5778 let mut action = SemanticsNode::new(
5779 SYNTHETIC_ACTION_ID,
5780 SemanticsRole::Button,
5781 Rect::new(ctx.bounds().x() + 8.0, ctx.bounds().y() + 8.0, 80.0, 32.0),
5782 );
5783 action.parent = Some(ctx.widget_id());
5784 action.name = Some("virtual action".to_string());
5785 let state = self.state.borrow();
5786 action.state.disabled = state.disabled;
5787 action.state.expanded = Some(state.expanded);
5788 action.actions = vec![
5789 SemanticsAction::Focus,
5790 SemanticsAction::Blur,
5791 SemanticsAction::Activate,
5792 SemanticsAction::Expand,
5793 SemanticsAction::Collapse,
5794 SemanticsAction::SetValue,
5795 SemanticsAction::InsertText,
5796 ];
5797 ctx.push(action);
5798 }
5799
5800 fn accepts_focus(&self) -> bool {
5801 true
5802 }
5803 }
5804
5805 impl Widget for FocusLeaf {
5806 fn event(&mut self, ctx: &mut EventCtx, event: &Event) {
5807 if let Event::Keyboard(_) = event {
5808 self.counters.borrow_mut().keyboard += 1;
5809 ctx.set_handled();
5810 }
5811 }
5812
5813 fn measure(&mut self, _ctx: &mut MeasureCtx, constraints: Constraints) -> Size {
5814 constraints.clamp(Size::new(120.0, 40.0))
5815 }
5816
5817 fn paint(&self, ctx: &mut PaintCtx) {
5818 self.counters.borrow_mut().paint += 1;
5819 ctx.fill_bounds(Color::rgba(0.22, 0.31, 0.42, 1.0));
5820 }
5821
5822 fn semantics(&self, ctx: &mut SemanticsCtx) {
5823 self.counters.borrow_mut().semantics += 1;
5824 let mut node = SemanticsNode::new(ctx.widget_id(), SemanticsRole::Button, ctx.bounds());
5825 node.name = Some("focus-leaf".to_string());
5826 node.actions = vec![SemanticsAction::Focus, SemanticsAction::Blur];
5827 ctx.push(node);
5828 }
5829
5830 fn accepts_focus(&self) -> bool {
5831 true
5832 }
5833
5834 fn focus_changed(&mut self, ctx: &mut EventCtx, _focused: bool) {
5835 self.counters.borrow_mut().focus_changes += 1;
5836 ctx.request_paint_rect(ctx.bounds());
5837 ctx.request_semantics();
5838 }
5839 }
5840
5841 #[test]
5842 fn focus_scope_restores_the_last_focused_descendant() {
5843 let state = FocusScopeState::new();
5844 let mut runtime = Application::new()
5845 .window(
5846 WindowBuilder::new().title("Focus Scope").root(
5847 FocusScope::new(FocusLeaf {
5848 counters: Rc::new(RefCell::new(Counters::default())),
5849 })
5850 .state(state.clone()),
5851 ),
5852 )
5853 .build()
5854 .unwrap();
5855 let window_id = runtime.window_ids()[0];
5856 let target = runtime
5857 .render(window_id)
5858 .unwrap()
5859 .semantics
5860 .into_iter()
5861 .find(|node| node.name.as_deref() == Some("focus-leaf"))
5862 .unwrap()
5863 .id;
5864
5865 assert!(
5866 runtime
5867 .handle_semantics_action(window_id, target, SemanticsActionRequest::Focus)
5868 .unwrap()
5869 );
5870 let _ = runtime.render(window_id).unwrap();
5871 assert_eq!(state.last_focused(), Some(target));
5872 assert!(
5873 runtime
5874 .handle_semantics_action(window_id, target, SemanticsActionRequest::Blur)
5875 .unwrap()
5876 );
5877 assert_eq!(runtime.focused_widget(window_id).unwrap(), None);
5878
5879 state.request_restore();
5880 let _ = runtime.render(window_id).unwrap();
5881 let ready = runtime.drain_ready_events();
5882 assert_eq!(ready.len(), 1);
5883 for (ready_window, event) in ready {
5884 runtime.handle_event(ready_window, event).unwrap();
5885 }
5886
5887 assert_eq!(runtime.focused_widget(window_id).unwrap(), Some(target));
5888 }
5889
5890 struct TestRoot {
5891 counters: Rc<RefCell<Counters>>,
5892 child: SingleChild,
5893 }
5894
5895 impl Widget for TestRoot {
5896 fn diagnostics(&self, ctx: &mut WidgetDiagnosticsCtx) {
5897 ctx.record("test state", "available");
5898 }
5899
5900 fn event(&mut self, ctx: &mut EventCtx, event: &Event) {
5901 if let Event::Custom(custom) = event
5902 && custom.kind == "semantics-only"
5903 {
5904 ctx.request_semantics();
5905 }
5906 }
5907
5908 fn measure(&mut self, ctx: &mut MeasureCtx, constraints: Constraints) -> Size {
5909 let size = constraints.clamp(Size::new(320.0, 180.0));
5910 self.child
5911 .measure(ctx, Constraints::tight(Size::new(120.0, 40.0)));
5912 size
5913 }
5914
5915 fn arrange(&mut self, ctx: &mut ArrangeCtx, bounds: Rect) {
5916 self.child.arrange(
5917 ctx,
5918 Rect::new(bounds.x() + 32.0, bounds.y() + 24.0, 120.0, 40.0),
5919 );
5920 }
5921
5922 fn paint(&self, ctx: &mut PaintCtx) {
5923 self.counters.borrow_mut().paint += 1;
5924 ctx.clear(Color::rgba(0.08, 0.09, 0.11, 1.0));
5925 self.child.paint(ctx);
5926 }
5927
5928 fn semantics(&self, ctx: &mut SemanticsCtx) {
5929 self.counters.borrow_mut().semantics += 1;
5930 ctx.push(SemanticsNode::new(
5931 ctx.widget_id(),
5932 SemanticsRole::Window,
5933 ctx.bounds(),
5934 ));
5935 self.child.semantics(ctx);
5936 }
5937
5938 fn visit_children(&self, visitor: &mut dyn WidgetPodVisitor) {
5939 self.child.visit_children(visitor);
5940 }
5941
5942 fn visit_children_mut(&mut self, visitor: &mut dyn WidgetPodMutVisitor) {
5943 self.child.visit_children_mut(visitor);
5944 }
5945 }
5946
5947 #[derive(Debug, Default)]
5948 struct VirtualizedPaintState {
5949 painted: Vec<usize>,
5950 }
5951
5952 struct VirtualizedLeaf {
5953 index: usize,
5954 state: Rc<RefCell<VirtualizedPaintState>>,
5955 }
5956
5957 impl Widget for VirtualizedLeaf {
5958 fn measure(&mut self, _ctx: &mut MeasureCtx, constraints: Constraints) -> Size {
5959 constraints.clamp(Size::new(48.0, 24.0))
5960 }
5961
5962 fn paint(&self, ctx: &mut PaintCtx) {
5963 self.state.borrow_mut().painted.push(self.index);
5964 ctx.fill_bounds(Color::rgba(0.18, 0.31, 0.42, 1.0));
5965 }
5966 }
5967
5968 struct VirtualizedLogicalRoot {
5969 children: WidgetChildren,
5970 visible_count: usize,
5971 }
5972
5973 impl VirtualizedLogicalRoot {
5974 fn new(
5975 logical_count: usize,
5976 visible_count: usize,
5977 state: Rc<RefCell<VirtualizedPaintState>>,
5978 ) -> Self {
5979 let mut children = WidgetChildren::with_capacity(logical_count);
5980 for index in 0..logical_count {
5981 children.push(VirtualizedLeaf {
5982 index,
5983 state: Rc::clone(&state),
5984 });
5985 }
5986 Self {
5987 children,
5988 visible_count,
5989 }
5990 }
5991 }
5992
5993 impl Widget for VirtualizedLogicalRoot {
5994 fn measure(&mut self, ctx: &mut MeasureCtx, constraints: Constraints) -> Size {
5995 for index in 0..self.children.len() {
5996 self.children
5997 .measure_child(index, ctx, Constraints::tight(Size::new(48.0, 24.0)));
5998 }
5999 constraints.clamp(Size::new(320.0, 180.0))
6000 }
6001
6002 fn arrange(&mut self, ctx: &mut ArrangeCtx, bounds: Rect) {
6003 for index in 0..self.children.len() {
6004 self.children.arrange_child(
6005 index,
6006 ctx,
6007 Rect::new(bounds.x() + (index as f32 * 52.0), bounds.y(), 48.0, 24.0),
6008 );
6009 }
6010 }
6011
6012 fn paint(&self, ctx: &mut PaintCtx) {
6013 ctx.clear(Color::rgba(0.08, 0.09, 0.11, 1.0));
6014 for child in self.children.as_slice().iter().take(self.visible_count) {
6015 child.paint(ctx);
6016 }
6017 }
6018
6019 fn visit_children(&self, visitor: &mut dyn WidgetPodVisitor) {
6020 self.children.visit_children(visitor);
6021 }
6022
6023 fn visit_children_mut(&mut self, visitor: &mut dyn WidgetPodMutVisitor) {
6024 self.children.visit_children_mut(visitor);
6025 }
6026 }
6027
6028 #[derive(Debug, Default)]
6029 struct ThreadedSnapshotState {
6030 async_token: Option<AsyncWakeToken>,
6031 latest: Option<String>,
6032 paints: usize,
6033 }
6034
6035 struct ThreadedSnapshotRoot {
6036 local: Rc<RefCell<ThreadedSnapshotState>>,
6037 inbox: Arc<Mutex<VecDeque<String>>>,
6038 }
6039
6040 impl Widget for ThreadedSnapshotRoot {
6041 fn event(&mut self, ctx: &mut EventCtx, event: &Event) {
6042 match event {
6043 Event::Custom(custom) if custom.kind == "arm-threaded-snapshot" => {
6044 self.local.borrow_mut().async_token = Some(ctx.register_async_wakeup());
6045 ctx.set_handled();
6046 }
6047 Event::Wake(WakeEvent::Async { token, .. }) => {
6048 let mut local = self.local.borrow_mut();
6049 if local.async_token == Some(*token) {
6050 while let Some(value) = self.inbox.lock().unwrap().pop_front() {
6051 local.latest = Some(value);
6052 }
6053 ctx.request_paint();
6054 ctx.set_handled();
6055 }
6056 }
6057 _ => {}
6058 }
6059 }
6060
6061 fn measure(&mut self, _ctx: &mut MeasureCtx, constraints: Constraints) -> Size {
6062 constraints.clamp(Size::new(160.0, 64.0))
6063 }
6064
6065 fn paint(&self, ctx: &mut PaintCtx) {
6066 self.local.borrow_mut().paints += 1;
6067 let active = self.local.borrow().latest.is_some();
6068 let color = if active {
6069 Color::rgba(0.20, 0.46, 0.30, 1.0)
6070 } else {
6071 Color::rgba(0.20, 0.24, 0.32, 1.0)
6072 };
6073 ctx.fill_bounds(color);
6074 }
6075 }
6076
6077 #[derive(Debug, Clone, Copy, PartialEq)]
6078 struct CachedLayerPresentation {
6079 translation: Vector,
6080 opacity: f32,
6081 }
6082
6083 impl Default for CachedLayerPresentation {
6084 fn default() -> Self {
6085 Self {
6086 translation: Vector::ZERO,
6087 opacity: 1.0,
6088 }
6089 }
6090 }
6091
6092 struct CachedMoveLeaf {
6093 counters: Rc<RefCell<Counters>>,
6094 presentation: Rc<RefCell<CachedLayerPresentation>>,
6095 }
6096
6097 impl Widget for CachedMoveLeaf {
6098 fn measure(&mut self, _ctx: &mut MeasureCtx, constraints: Constraints) -> Size {
6099 constraints.clamp(Size::new(220.0, 72.0))
6100 }
6101
6102 fn paint(&self, ctx: &mut PaintCtx) {
6103 self.counters.borrow_mut().paint += 1;
6104 ctx.fill_bounds(Color::rgba(0.14, 0.42, 0.72, 1.0));
6105 }
6106
6107 fn layer_options(&self) -> LayerOptions {
6108 LayerOptions {
6109 paint_boundary: PaintBoundaryMode::Explicit,
6110 composition_mode: sui_scene::LayerCompositionMode::Scroll,
6111 }
6112 }
6113
6114 fn layer_properties(&self) -> LayerProperties {
6115 let presentation = *self.presentation.borrow();
6116 LayerProperties::default()
6117 .with_translation(presentation.translation)
6118 .with_opacity(presentation.opacity)
6119 }
6120 }
6121
6122 struct DirectMoveLeaf {
6123 counters: Rc<RefCell<Counters>>,
6124 }
6125
6126 impl Widget for DirectMoveLeaf {
6127 fn measure(&mut self, _ctx: &mut MeasureCtx, constraints: Constraints) -> Size {
6128 constraints.clamp(Size::new(140.0, 48.0))
6129 }
6130
6131 fn paint(&self, ctx: &mut PaintCtx) {
6132 self.counters.borrow_mut().paint += 1;
6133 ctx.fill_bounds(Color::rgba(0.78, 0.43, 0.14, 1.0));
6134 }
6135 }
6136
6137 struct OverpaintLeaf {
6138 size: Size,
6139 color: Color,
6140 bleed: Vector,
6141 }
6142
6143 impl Widget for OverpaintLeaf {
6144 fn measure(&mut self, _ctx: &mut MeasureCtx, constraints: Constraints) -> Size {
6145 constraints.clamp(self.size)
6146 }
6147
6148 fn paint(&self, ctx: &mut PaintCtx) {
6149 ctx.fill_rect(
6150 ctx.bounds().inflate(self.bleed.x.abs(), self.bleed.y.abs()),
6151 self.color,
6152 );
6153 }
6154 }
6155
6156 struct PointerCountingLeaf {
6157 pointer_downs: Rc<RefCell<usize>>,
6158 }
6159
6160 impl Widget for PointerCountingLeaf {
6161 fn event(&mut self, ctx: &mut EventCtx, event: &Event) {
6162 if matches!(
6163 event,
6164 Event::Pointer(pointer)
6165 if pointer.kind == PointerEventKind::Down
6166 && pointer.button == Some(PointerButton::Primary)
6167 ) {
6168 *self.pointer_downs.borrow_mut() += 1;
6169 ctx.set_handled();
6170 }
6171 }
6172
6173 fn measure(&mut self, _ctx: &mut MeasureCtx, constraints: Constraints) -> Size {
6174 constraints.clamp(Size::new(120.0, 40.0))
6175 }
6176
6177 fn paint(&self, ctx: &mut PaintCtx) {
6178 ctx.fill_bounds(Color::rgba(0.15, 0.35, 0.58, 1.0));
6179 }
6180 }
6181
6182 struct NonHitTestOverlayLeaf;
6183
6184 impl Widget for NonHitTestOverlayLeaf {
6185 fn measure(&mut self, _ctx: &mut MeasureCtx, constraints: Constraints) -> Size {
6186 constraints.clamp(Size::new(120.0, 40.0))
6187 }
6188
6189 fn paint(&self, ctx: &mut PaintCtx) {
6190 ctx.fill_bounds(Color::rgba(0.9, 0.2, 0.2, 0.35));
6191 }
6192
6193 fn layer_options(&self) -> LayerOptions {
6194 LayerOptions {
6195 paint_boundary: PaintBoundaryMode::Explicit,
6196 composition_mode: LayerCompositionMode::Overlay,
6197 }
6198 }
6199
6200 fn stack_surface_options(&self) -> Option<StackSurfaceOptions> {
6201 Some(StackSurfaceOptions {
6202 hit_test: false,
6203 ..StackSurfaceOptions::default()
6204 })
6205 }
6206 }
6207
6208 struct OverlayPassThroughRoot {
6209 children: WidgetChildren,
6210 }
6211
6212 impl OverlayPassThroughRoot {
6213 fn new(pointer_downs: Rc<RefCell<usize>>) -> Self {
6214 let mut children = WidgetChildren::with_capacity(2);
6215 children.push(PointerCountingLeaf { pointer_downs });
6216 children.push(NonHitTestOverlayLeaf);
6217 Self { children }
6218 }
6219 }
6220
6221 impl Widget for OverlayPassThroughRoot {
6222 fn measure(&mut self, ctx: &mut MeasureCtx, constraints: Constraints) -> Size {
6223 let size = constraints.clamp(Size::new(320.0, 180.0));
6224 self.children
6225 .measure_child(0, ctx, Constraints::tight(Size::new(120.0, 40.0)));
6226 self.children
6227 .measure_child(1, ctx, Constraints::tight(Size::new(120.0, 40.0)));
6228 size
6229 }
6230
6231 fn arrange(&mut self, ctx: &mut ArrangeCtx, bounds: Rect) {
6232 let child_bounds = Rect::new(bounds.x() + 32.0, bounds.y() + 24.0, 120.0, 40.0);
6233 self.children.arrange_child(0, ctx, child_bounds);
6234 self.children.arrange_child(1, ctx, child_bounds);
6235 }
6236
6237 fn paint(&self, ctx: &mut PaintCtx) {
6238 ctx.clear(Color::rgba(0.08, 0.09, 0.11, 1.0));
6239 self.children.paint(ctx);
6240 }
6241
6242 fn visit_children(&self, visitor: &mut dyn WidgetPodVisitor) {
6243 self.children.visit_children(visitor);
6244 }
6245
6246 fn visit_children_mut(&mut self, visitor: &mut dyn WidgetPodMutVisitor) {
6247 self.children.visit_children_mut(visitor);
6248 }
6249 }
6250
6251 struct HitTestOverlaySurface {
6252 child: SingleChild,
6253 }
6254
6255 impl HitTestOverlaySurface {
6256 fn new(pointer_downs: Rc<RefCell<usize>>) -> Self {
6257 Self {
6258 child: SingleChild::new(PointerCountingLeaf { pointer_downs }),
6259 }
6260 }
6261 }
6262
6263 impl Widget for HitTestOverlaySurface {
6264 fn measure(&mut self, ctx: &mut MeasureCtx, constraints: Constraints) -> Size {
6265 self.child
6266 .measure(ctx, Constraints::tight(Size::new(120.0, 40.0)));
6267 constraints.clamp(Size::new(180.0, 90.0))
6268 }
6269
6270 fn arrange(&mut self, ctx: &mut ArrangeCtx, bounds: Rect) {
6271 self.child.arrange(
6272 ctx,
6273 Rect::new(bounds.x() + 24.0, bounds.y() + 20.0, 120.0, 40.0),
6274 );
6275 }
6276
6277 fn paint(&self, ctx: &mut PaintCtx) {
6278 ctx.fill_bounds(Color::rgba(0.9, 0.2, 0.2, 0.35));
6279 self.child.paint(ctx);
6280 }
6281
6282 fn layer_options(&self) -> LayerOptions {
6283 LayerOptions {
6284 paint_boundary: PaintBoundaryMode::Explicit,
6285 composition_mode: LayerCompositionMode::Effect,
6286 }
6287 }
6288
6289 fn stack_surface_options(&self) -> Option<StackSurfaceOptions> {
6290 Some(StackSurfaceOptions::default())
6291 }
6292
6293 fn visit_children(&self, visitor: &mut dyn WidgetPodVisitor) {
6294 self.child.visit_children(visitor);
6295 }
6296
6297 fn visit_children_mut(&mut self, visitor: &mut dyn WidgetPodMutVisitor) {
6298 self.child.visit_children_mut(visitor);
6299 }
6300 }
6301
6302 struct HitTestOverlayRoot {
6303 child: SingleChild,
6304 }
6305
6306 impl HitTestOverlayRoot {
6307 fn new(pointer_downs: Rc<RefCell<usize>>) -> Self {
6308 Self {
6309 child: SingleChild::new(HitTestOverlaySurface::new(pointer_downs)),
6310 }
6311 }
6312 }
6313
6314 impl Widget for HitTestOverlayRoot {
6315 fn measure(&mut self, ctx: &mut MeasureCtx, constraints: Constraints) -> Size {
6316 self.child
6317 .measure(ctx, Constraints::tight(Size::new(180.0, 90.0)));
6318 constraints.clamp(Size::new(320.0, 180.0))
6319 }
6320
6321 fn arrange(&mut self, ctx: &mut ArrangeCtx, bounds: Rect) {
6322 self.child.arrange(
6323 ctx,
6324 Rect::new(bounds.x() + 20.0, bounds.y() + 20.0, 180.0, 90.0),
6325 );
6326 }
6327
6328 fn paint(&self, ctx: &mut PaintCtx) {
6329 ctx.clear(Color::rgba(0.08, 0.09, 0.11, 1.0));
6330 self.child.paint(ctx);
6331 }
6332
6333 fn visit_children(&self, visitor: &mut dyn WidgetPodVisitor) {
6334 self.child.visit_children(visitor);
6335 }
6336
6337 fn visit_children_mut(&mut self, visitor: &mut dyn WidgetPodMutVisitor) {
6338 self.child.visit_children_mut(visitor);
6339 }
6340 }
6341
6342 struct DirectMoveRoot {
6343 counters: Rc<RefCell<Counters>>,
6344 child: SingleChild,
6345 offset_x: f32,
6346 }
6347
6348 impl Widget for DirectMoveRoot {
6349 fn event(&mut self, ctx: &mut EventCtx, event: &Event) {
6350 if let Event::Custom(custom) = event
6351 && custom.kind == "shift-direct"
6352 {
6353 self.offset_x += 36.0;
6354 ctx.request_arrange();
6355 }
6356 }
6357
6358 fn measure(&mut self, ctx: &mut MeasureCtx, constraints: Constraints) -> Size {
6359 let size = constraints.clamp(Size::new(320.0, 180.0));
6360 self.child
6361 .measure(ctx, Constraints::tight(Size::new(140.0, 48.0)));
6362 size
6363 }
6364
6365 fn arrange(&mut self, ctx: &mut ArrangeCtx, bounds: Rect) {
6366 self.child.arrange(
6367 ctx,
6368 Rect::new(
6369 bounds.x() + 28.0 + self.offset_x,
6370 bounds.y() + 32.0,
6371 140.0,
6372 48.0,
6373 ),
6374 );
6375 }
6376
6377 fn paint(&self, ctx: &mut PaintCtx) {
6378 self.counters.borrow_mut().paint += 1;
6379 ctx.clear(Color::rgba(0.08, 0.09, 0.11, 1.0));
6380 self.child.paint(ctx);
6381 }
6382
6383 fn visit_children(&self, visitor: &mut dyn WidgetPodVisitor) {
6384 self.child.visit_children(visitor);
6385 }
6386
6387 fn visit_children_mut(&mut self, visitor: &mut dyn WidgetPodMutVisitor) {
6388 self.child.visit_children_mut(visitor);
6389 }
6390 }
6391
6392 struct CachedMoveRoot {
6393 counters: Rc<RefCell<Counters>>,
6394 child: SingleChild,
6395 presentation: Rc<RefCell<CachedLayerPresentation>>,
6396 offset_x: f32,
6397 paint_background: bool,
6398 }
6399
6400 impl Widget for CachedMoveRoot {
6401 fn event(&mut self, ctx: &mut EventCtx, event: &Event) {
6402 if let Event::Custom(custom) = event
6403 && custom.kind == "shift-cached"
6404 {
6405 self.offset_x += 48.0;
6406 ctx.request_arrange();
6407 }
6408 if let Event::Custom(custom) = event
6409 && custom.kind == "nudge-cached-layer-property"
6410 {
6411 self.presentation.borrow_mut().translation += Vector::new(18.0, 0.0);
6412 ctx.request_transform();
6413 }
6414 if let Event::Custom(custom) = event
6415 && custom.kind == "fade-cached-layer"
6416 {
6417 self.presentation.borrow_mut().opacity = 0.5;
6418 ctx.request_effect();
6419 }
6420 }
6421
6422 fn measure(&mut self, ctx: &mut MeasureCtx, constraints: Constraints) -> Size {
6423 let size = constraints.clamp(Size::new(320.0, 180.0));
6424 self.child
6425 .measure(ctx, Constraints::tight(Size::new(220.0, 72.0)));
6426 size
6427 }
6428
6429 fn arrange(&mut self, ctx: &mut ArrangeCtx, bounds: Rect) {
6430 self.child.arrange(
6431 ctx,
6432 Rect::new(
6433 bounds.x() + 24.0 + self.offset_x,
6434 bounds.y() + 28.0,
6435 220.0,
6436 72.0,
6437 ),
6438 );
6439 }
6440
6441 fn paint(&self, ctx: &mut PaintCtx) {
6442 self.counters.borrow_mut().paint += 1;
6443 if self.paint_background {
6444 ctx.clear(Color::rgba(0.08, 0.09, 0.11, 1.0));
6445 }
6446 self.child.paint(ctx);
6447 }
6448
6449 fn visit_children(&self, visitor: &mut dyn WidgetPodVisitor) {
6450 self.child.visit_children(visitor);
6451 }
6452
6453 fn visit_children_mut(&mut self, visitor: &mut dyn WidgetPodMutVisitor) {
6454 self.child.visit_children_mut(visitor);
6455 }
6456 }
6457
6458 struct FocusTraversalRoot {
6459 children: WidgetChildren,
6460 }
6461
6462 struct ManagedOverlayTestRoot {
6463 open: Rc<RefCell<bool>>,
6464 children: WidgetChildren,
6465 }
6466
6467 impl ManagedOverlayTestRoot {
6468 fn new(
6469 open: Rc<RefCell<bool>>,
6470 dismissals: Rc<RefCell<Vec<OverlayDismissReason>>>,
6471 ) -> Self {
6472 let mut overlay_children = WidgetChildren::with_capacity(2);
6473 overlay_children.push(FocusLeaf {
6474 counters: Rc::new(RefCell::new(Counters::default())),
6475 });
6476 overlay_children.push(FocusLeaf {
6477 counters: Rc::new(RefCell::new(Counters::default())),
6478 });
6479
6480 let mut children = WidgetChildren::with_capacity(2);
6481 children.push(FocusLeaf {
6482 counters: Rc::new(RefCell::new(Counters::default())),
6483 });
6484 children.push(ManagedOverlayTestWidget {
6485 open: Rc::clone(&open),
6486 dismissals,
6487 children: overlay_children,
6488 });
6489 Self { open, children }
6490 }
6491 }
6492
6493 impl Widget for ManagedOverlayTestRoot {
6494 fn event(&mut self, ctx: &mut EventCtx, event: &Event) {
6495 if let Event::Custom(custom) = event
6496 && custom.kind == "open-managed-overlay"
6497 {
6498 *self.open.borrow_mut() = true;
6499 ctx.request_measure();
6500 ctx.request_semantics();
6501 ctx.set_handled();
6502 }
6503 }
6504
6505 fn measure(&mut self, ctx: &mut MeasureCtx, constraints: Constraints) -> Size {
6506 let size = constraints.clamp(Size::new(360.0, 220.0));
6507 self.children
6508 .measure_child(0, ctx, Constraints::tight(Size::new(100.0, 40.0)));
6509 self.children
6510 .measure_child(1, ctx, Constraints::tight(Size::new(160.0, 120.0)));
6511 size
6512 }
6513
6514 fn arrange(&mut self, ctx: &mut ArrangeCtx, bounds: Rect) {
6515 self.children.arrange_child(
6516 0,
6517 ctx,
6518 Rect::new(bounds.x() + 20.0, bounds.y() + 20.0, 100.0, 40.0),
6519 );
6520 self.children.arrange_child(
6521 1,
6522 ctx,
6523 Rect::new(bounds.x() + 160.0, bounds.y() + 20.0, 160.0, 120.0),
6524 );
6525 }
6526
6527 fn paint(&self, ctx: &mut PaintCtx) {
6528 ctx.clear(Color::rgba(0.08, 0.09, 0.11, 1.0));
6529 self.children.paint(ctx);
6530 }
6531
6532 fn semantics(&self, ctx: &mut SemanticsCtx) {
6533 ctx.push(SemanticsNode::new(
6534 ctx.widget_id(),
6535 SemanticsRole::Window,
6536 ctx.bounds(),
6537 ));
6538 self.children.semantics(ctx);
6539 }
6540
6541 fn visit_children(&self, visitor: &mut dyn WidgetPodVisitor) {
6542 self.children.visit_children(visitor);
6543 }
6544
6545 fn visit_children_mut(&mut self, visitor: &mut dyn WidgetPodMutVisitor) {
6546 self.children.visit_children_mut(visitor);
6547 }
6548 }
6549
6550 struct ManagedOverlayTestWidget {
6551 open: Rc<RefCell<bool>>,
6552 dismissals: Rc<RefCell<Vec<OverlayDismissReason>>>,
6553 children: WidgetChildren,
6554 }
6555
6556 impl Widget for ManagedOverlayTestWidget {
6557 fn command(&mut self, ctx: &mut EventCtx, command: &Command<'_>) {
6558 let Some(request) = command.get(OVERLAY_DISMISS_REQUEST) else {
6559 return;
6560 };
6561 self.dismissals.borrow_mut().push(request.reason);
6562 *self.open.borrow_mut() = false;
6563 ctx.request_measure();
6564 ctx.request_semantics();
6565 ctx.set_handled();
6566 }
6567
6568 fn measure(&mut self, ctx: &mut MeasureCtx, constraints: Constraints) -> Size {
6569 let size = constraints.clamp(Size::new(160.0, 120.0));
6570 self.children
6571 .measure_child(0, ctx, Constraints::tight(Size::new(120.0, 40.0)));
6572 self.children
6573 .measure_child(1, ctx, Constraints::tight(Size::new(120.0, 40.0)));
6574 size
6575 }
6576
6577 fn arrange(&mut self, ctx: &mut ArrangeCtx, bounds: Rect) {
6578 self.children.arrange_child(
6579 0,
6580 ctx,
6581 Rect::new(bounds.x() + 20.0, bounds.y() + 12.0, 120.0, 40.0),
6582 );
6583 self.children.arrange_child(
6584 1,
6585 ctx,
6586 Rect::new(bounds.x() + 20.0, bounds.y() + 64.0, 120.0, 40.0),
6587 );
6588 }
6589
6590 fn paint(&self, ctx: &mut PaintCtx) {
6591 self.children.paint(ctx);
6592 }
6593
6594 fn semantics(&self, ctx: &mut SemanticsCtx) {
6595 if *self.open.borrow() {
6596 let mut node =
6597 SemanticsNode::new(ctx.widget_id(), SemanticsRole::Dialog, ctx.bounds());
6598 node.name = Some("managed overlay".to_string());
6599 ctx.push(node);
6600 }
6601 self.children.semantics(ctx);
6602 }
6603
6604 fn overlay_options(&self) -> Option<OverlayOptions> {
6605 (*self.open.borrow()).then_some(
6606 OverlayOptions::new(OverlayKind::Dialog)
6607 .modal(true)
6608 .focus(OverlayFocusBehavior::CONTAINED),
6609 )
6610 }
6611
6612 fn visit_children(&self, visitor: &mut dyn WidgetPodVisitor) {
6613 self.children.visit_children(visitor);
6614 }
6615
6616 fn visit_children_mut(&mut self, visitor: &mut dyn WidgetPodMutVisitor) {
6617 self.children.visit_children_mut(visitor);
6618 }
6619 }
6620
6621 impl FocusTraversalRoot {
6622 fn new(first: Rc<RefCell<Counters>>, second: Rc<RefCell<Counters>>) -> Self {
6623 let mut children = WidgetChildren::with_capacity(2);
6624 children.push(FocusLeaf { counters: first });
6625 children.push(FocusLeaf { counters: second });
6626 Self { children }
6627 }
6628 }
6629
6630 impl Widget for FocusTraversalRoot {
6631 fn measure(&mut self, ctx: &mut MeasureCtx, constraints: Constraints) -> Size {
6632 let size = constraints.clamp(Size::new(320.0, 180.0));
6633 self.children
6634 .measure_child(0, ctx, Constraints::tight(Size::new(120.0, 40.0)));
6635 self.children
6636 .measure_child(1, ctx, Constraints::tight(Size::new(120.0, 40.0)));
6637 size
6638 }
6639
6640 fn arrange(&mut self, ctx: &mut ArrangeCtx, bounds: Rect) {
6641 self.children.arrange_child(
6642 0,
6643 ctx,
6644 Rect::new(bounds.x() + 32.0, bounds.y() + 24.0, 120.0, 40.0),
6645 );
6646 self.children.arrange_child(
6647 1,
6648 ctx,
6649 Rect::new(bounds.x() + 32.0, bounds.y() + 80.0, 120.0, 40.0),
6650 );
6651 }
6652
6653 fn paint(&self, ctx: &mut PaintCtx) {
6654 ctx.clear(Color::rgba(0.08, 0.09, 0.11, 1.0));
6655 self.children.paint(ctx);
6656 }
6657
6658 fn semantics(&self, ctx: &mut SemanticsCtx) {
6659 ctx.push(SemanticsNode::new(
6660 ctx.widget_id(),
6661 SemanticsRole::Window,
6662 ctx.bounds(),
6663 ));
6664 self.children.semantics(ctx);
6665 }
6666
6667 fn visit_children(&self, visitor: &mut dyn WidgetPodVisitor) {
6668 self.children.visit_children(visitor);
6669 }
6670
6671 fn visit_children_mut(&mut self, visitor: &mut dyn WidgetPodMutVisitor) {
6672 self.children.visit_children_mut(visitor);
6673 }
6674 }
6675
6676 struct HoverTransitionRoot {
6677 children: WidgetChildren,
6678 }
6679
6680 impl HoverTransitionRoot {
6681 fn new(
6682 first: Rc<RefCell<HoverTransitionState>>,
6683 second: Rc<RefCell<HoverTransitionState>>,
6684 ) -> Self {
6685 let mut children = WidgetChildren::with_capacity(2);
6686 children.push(HoverTransitionLeaf {
6687 name: "hover-first",
6688 state: first,
6689 });
6690 children.push(HoverTransitionLeaf {
6691 name: "hover-second",
6692 state: second,
6693 });
6694 Self { children }
6695 }
6696 }
6697
6698 impl Widget for HoverTransitionRoot {
6699 fn measure(&mut self, ctx: &mut MeasureCtx, constraints: Constraints) -> Size {
6700 let size = constraints.clamp(Size::new(320.0, 180.0));
6701 self.children
6702 .measure_child(0, ctx, Constraints::tight(Size::new(120.0, 40.0)));
6703 self.children
6704 .measure_child(1, ctx, Constraints::tight(Size::new(120.0, 40.0)));
6705 size
6706 }
6707
6708 fn arrange(&mut self, ctx: &mut ArrangeCtx, bounds: Rect) {
6709 self.children.arrange_child(
6710 0,
6711 ctx,
6712 Rect::new(bounds.x() + 32.0, bounds.y() + 24.0, 120.0, 40.0),
6713 );
6714 self.children.arrange_child(
6715 1,
6716 ctx,
6717 Rect::new(bounds.x() + 172.0, bounds.y() + 24.0, 120.0, 40.0),
6718 );
6719 }
6720
6721 fn paint(&self, ctx: &mut PaintCtx) {
6722 ctx.clear(Color::rgba(0.08, 0.09, 0.11, 1.0));
6723 self.children.paint(ctx);
6724 }
6725
6726 fn semantics(&self, ctx: &mut SemanticsCtx) {
6727 ctx.push(SemanticsNode::new(
6728 ctx.widget_id(),
6729 SemanticsRole::Window,
6730 ctx.bounds(),
6731 ));
6732 self.children.semantics(ctx);
6733 }
6734
6735 fn visit_children(&self, visitor: &mut dyn WidgetPodVisitor) {
6736 self.children.visit_children(visitor);
6737 }
6738
6739 fn visit_children_mut(&mut self, visitor: &mut dyn WidgetPodMutVisitor) {
6740 self.children.visit_children_mut(visitor);
6741 }
6742 }
6743
6744 #[derive(Default)]
6745 struct PointerCaptureState {
6746 moves: usize,
6747 ups: usize,
6748 cancels: usize,
6749 cancel_followups: usize,
6750 last_cancel: Option<PointerEvent>,
6751 }
6752
6753 #[derive(Debug, Default)]
6754 struct RuntimeDragState {
6755 source_moves: usize,
6756 target_overs: usize,
6757 drops: usize,
6758 ends: usize,
6759 outcome: Option<DragOutcome>,
6760 }
6761
6762 #[derive(Default, Debug, Clone, Copy, PartialEq, Eq)]
6763 struct HoverTransitionState {
6764 enters: usize,
6765 leaves: usize,
6766 hovered: bool,
6767 }
6768
6769 struct PointerCaptureLeaf {
6770 state: Rc<RefCell<PointerCaptureState>>,
6771 recapture_on_move: bool,
6772 }
6773
6774 struct PointerCaptureTransferRoot {
6775 child: SingleChild,
6776 }
6777
6778 #[derive(Default)]
6779 struct ReentrantCaptureState {
6780 intermediate_id: Option<WidgetId>,
6781 pointer_id: Option<u64>,
6782 source_cancels: usize,
6783 intermediate_captures: usize,
6784 intermediate_cancels: usize,
6785 }
6786
6787 struct ReentrantCaptureSource {
6788 state: Rc<RefCell<ReentrantCaptureState>>,
6789 }
6790
6791 struct ReentrantCaptureIntermediate {
6792 state: Rc<RefCell<ReentrantCaptureState>>,
6793 }
6794
6795 struct ReentrantCaptureRoot {
6796 children: WidgetChildren,
6797 }
6798
6799 struct RuntimeDragSource {
6800 state: Rc<RefCell<RuntimeDragState>>,
6801 scope: DragScopeId,
6802 session: Option<DragSessionId>,
6803 }
6804
6805 struct RuntimeDragTarget {
6806 state: Rc<RefCell<RuntimeDragState>>,
6807 scope: DragScopeId,
6808 }
6809
6810 struct RuntimeDragRoot {
6811 children: WidgetChildren,
6812 }
6813
6814 struct HoverTransitionLeaf {
6815 name: &'static str,
6816 state: Rc<RefCell<HoverTransitionState>>,
6817 }
6818
6819 impl Widget for PointerCaptureLeaf {
6820 fn event(&mut self, ctx: &mut EventCtx, event: &Event) {
6821 if let Event::Custom(custom) = event
6822 && custom.kind == "pointer-cancel-followup"
6823 {
6824 self.state.borrow_mut().cancel_followups += 1;
6825 return;
6826 }
6827
6828 let Event::Pointer(pointer) = event else {
6829 return;
6830 };
6831
6832 match pointer.kind {
6833 PointerEventKind::Down => {
6834 ctx.request_pointer_capture(pointer.pointer_id);
6835 ctx.set_handled();
6836 }
6837 PointerEventKind::Move => {
6838 self.state.borrow_mut().moves += 1;
6839 if self.recapture_on_move {
6840 ctx.request_pointer_capture(pointer.pointer_id);
6841 }
6842 ctx.set_handled();
6843 }
6844 PointerEventKind::Up => {
6845 self.state.borrow_mut().ups += 1;
6846 ctx.set_handled();
6847 }
6848 PointerEventKind::Cancel => {
6849 let mut state = self.state.borrow_mut();
6850 state.cancels += 1;
6851 state.last_cancel = Some(pointer.clone());
6852 drop(state);
6853 ctx.release_pointer_capture(pointer.pointer_id);
6854 ctx.request_paint();
6855 ctx.post_event(
6856 ctx.widget_id(),
6857 Event::Custom(CustomEvent::new("pointer-cancel-followup")),
6858 );
6859 ctx.set_handled();
6860 }
6861 _ => {}
6862 }
6863 }
6864
6865 fn measure(&mut self, _ctx: &mut MeasureCtx, constraints: Constraints) -> Size {
6866 constraints.clamp(Size::new(120.0, 40.0))
6867 }
6868 }
6869
6870 impl PointerCaptureTransferRoot {
6871 fn new(child: PointerCaptureLeaf) -> Self {
6872 Self {
6873 child: SingleChild::new(child),
6874 }
6875 }
6876 }
6877
6878 impl Widget for PointerCaptureTransferRoot {
6879 fn event(&mut self, ctx: &mut EventCtx, event: &Event) {
6880 if let Event::Pointer(pointer) = event
6881 && pointer.kind == PointerEventKind::Move
6882 && ctx.phase() == EventPhase::Capture
6883 {
6884 ctx.request_pointer_capture(pointer.pointer_id);
6885 }
6886 }
6887
6888 fn measure(&mut self, ctx: &mut MeasureCtx, constraints: Constraints) -> Size {
6889 let size = constraints.clamp(Size::new(320.0, 180.0));
6890 self.child
6891 .measure(ctx, Constraints::tight(Size::new(120.0, 40.0)));
6892 size
6893 }
6894
6895 fn arrange(&mut self, ctx: &mut ArrangeCtx, bounds: Rect) {
6896 self.child.arrange(
6897 ctx,
6898 Rect::new(bounds.x() + 32.0, bounds.y() + 24.0, 120.0, 40.0),
6899 );
6900 }
6901
6902 fn visit_children(&self, visitor: &mut dyn WidgetPodVisitor) {
6903 self.child.visit_children(visitor);
6904 }
6905
6906 fn visit_children_mut(&mut self, visitor: &mut dyn WidgetPodMutVisitor) {
6907 self.child.visit_children_mut(visitor);
6908 }
6909 }
6910
6911 impl ReentrantCaptureRoot {
6912 fn new(state: Rc<RefCell<ReentrantCaptureState>>) -> Self {
6913 let mut children = WidgetChildren::with_capacity(2);
6914 children.push(ReentrantCaptureSource {
6915 state: Rc::clone(&state),
6916 });
6917 children.push(ReentrantCaptureIntermediate { state });
6918 Self { children }
6919 }
6920 }
6921
6922 impl Widget for ReentrantCaptureRoot {
6923 fn event(&mut self, ctx: &mut EventCtx, event: &Event) {
6924 if let Event::Pointer(pointer) = event
6925 && pointer.kind == PointerEventKind::Move
6926 && ctx.phase() == EventPhase::Capture
6927 {
6928 ctx.request_pointer_capture(pointer.pointer_id);
6929 }
6930 }
6931
6932 fn measure(&mut self, ctx: &mut MeasureCtx, constraints: Constraints) -> Size {
6933 let size = constraints.clamp(Size::new(320.0, 180.0));
6934 self.children
6935 .measure_child(0, ctx, Constraints::tight(Size::new(120.0, 40.0)));
6936 self.children
6937 .measure_child(1, ctx, Constraints::tight(Size::new(80.0, 40.0)));
6938 size
6939 }
6940
6941 fn arrange(&mut self, ctx: &mut ArrangeCtx, bounds: Rect) {
6942 self.children.arrange_child(
6943 0,
6944 ctx,
6945 Rect::new(bounds.x() + 32.0, bounds.y() + 24.0, 120.0, 40.0),
6946 );
6947 self.children.arrange_child(
6948 1,
6949 ctx,
6950 Rect::new(bounds.x() + 180.0, bounds.y() + 24.0, 80.0, 40.0),
6951 );
6952 }
6953
6954 fn visit_children(&self, visitor: &mut dyn WidgetPodVisitor) {
6955 self.children.visit_children(visitor);
6956 }
6957
6958 fn visit_children_mut(&mut self, visitor: &mut dyn WidgetPodMutVisitor) {
6959 self.children.visit_children_mut(visitor);
6960 }
6961 }
6962
6963 impl Widget for ReentrantCaptureSource {
6964 fn event(&mut self, ctx: &mut EventCtx, event: &Event) {
6965 let Event::Pointer(pointer) = event else {
6966 return;
6967 };
6968
6969 match pointer.kind {
6970 PointerEventKind::Down => {
6971 ctx.request_pointer_capture(pointer.pointer_id);
6972 ctx.set_handled();
6973 }
6974 PointerEventKind::Move => {
6975 ctx.set_handled();
6976 }
6977 PointerEventKind::Cancel => {
6978 let intermediate_id = {
6979 let mut state = self.state.borrow_mut();
6980 state.source_cancels += 1;
6981 state.pointer_id = Some(pointer.pointer_id);
6982 state.intermediate_id.expect("intermediate measured")
6983 };
6984 ctx.release_pointer_capture(pointer.pointer_id);
6985 ctx.post_event(
6986 intermediate_id,
6987 Event::Custom(CustomEvent::new("capture-intermediate")),
6988 );
6989 ctx.set_handled();
6990 }
6991 _ => {}
6992 }
6993 }
6994
6995 fn measure(&mut self, _ctx: &mut MeasureCtx, constraints: Constraints) -> Size {
6996 constraints.clamp(Size::new(120.0, 40.0))
6997 }
6998 }
6999
7000 impl Widget for ReentrantCaptureIntermediate {
7001 fn event(&mut self, ctx: &mut EventCtx, event: &Event) {
7002 match event {
7003 Event::Custom(custom) if custom.kind == "capture-intermediate" => {
7004 let pointer_id = self.state.borrow().pointer_id.expect("pointer recorded");
7005 self.state.borrow_mut().intermediate_captures += 1;
7006 ctx.request_pointer_capture(pointer_id);
7007 }
7008 Event::Pointer(pointer) if pointer.kind == PointerEventKind::Cancel => {
7009 self.state.borrow_mut().intermediate_cancels += 1;
7010 ctx.release_pointer_capture(pointer.pointer_id);
7011 ctx.set_handled();
7012 }
7013 _ => {}
7014 }
7015 }
7016
7017 fn measure(&mut self, ctx: &mut MeasureCtx, constraints: Constraints) -> Size {
7018 self.state.borrow_mut().intermediate_id = Some(ctx.widget_id());
7019 constraints.clamp(Size::new(80.0, 40.0))
7020 }
7021 }
7022
7023 impl Widget for RuntimeDragSource {
7024 fn event(&mut self, ctx: &mut EventCtx, event: &Event) {
7025 match event {
7026 Event::Pointer(pointer) => match pointer.kind {
7027 PointerEventKind::Down => {
7028 ctx.request_pointer_capture(pointer.pointer_id);
7029 ctx.set_handled();
7030 }
7031 PointerEventKind::Move if pointer.buttons.contains(PointerButton::Primary) => {
7032 self.state.borrow_mut().source_moves += 1;
7033 if self.session.is_none() {
7034 self.session = Some(ctx.begin_drag(
7035 self.scope,
7036 pointer.pointer_id,
7037 pointer.position,
7038 DragPayload::text("runtime"),
7039 DropEffect::Move,
7040 Some("runtime".to_string()),
7041 ));
7042 }
7043 ctx.set_handled();
7044 }
7045 PointerEventKind::Up => {
7046 ctx.set_handled();
7047 }
7048 _ => {}
7049 },
7050 Event::Drag(drag)
7051 if drag.kind == DragEventKind::End && self.session == Some(drag.session_id) =>
7052 {
7053 let mut state = self.state.borrow_mut();
7054 state.ends += 1;
7055 state.outcome = drag.outcome;
7056 self.session = None;
7057 ctx.set_handled();
7058 }
7059 _ => {}
7060 }
7061 }
7062
7063 fn measure(&mut self, _ctx: &mut MeasureCtx, constraints: Constraints) -> Size {
7064 constraints.clamp(Size::new(120.0, 40.0))
7065 }
7066 }
7067
7068 impl Widget for RuntimeDragTarget {
7069 fn event(&mut self, ctx: &mut EventCtx, event: &Event) {
7070 let Event::Drag(drag) = event else {
7071 return;
7072 };
7073 if drag.scope_id != self.scope {
7074 return;
7075 }
7076 match drag.kind {
7077 DragEventKind::Over => {
7078 self.state.borrow_mut().target_overs += 1;
7079 ctx.accept_drop(DropEffect::Move);
7080 }
7081 DragEventKind::Drop => {
7082 self.state.borrow_mut().drops += 1;
7083 ctx.set_handled();
7084 }
7085 _ => {}
7086 }
7087 }
7088
7089 fn measure(&mut self, _ctx: &mut MeasureCtx, constraints: Constraints) -> Size {
7090 constraints.clamp(Size::new(120.0, 40.0))
7091 }
7092 }
7093
7094 impl RuntimeDragRoot {
7095 fn new(state: Rc<RefCell<RuntimeDragState>>) -> Self {
7096 let scope = DragScopeId::new(77);
7097 let mut children = WidgetChildren::with_capacity(2);
7098 children.push(RuntimeDragSource {
7099 state: Rc::clone(&state),
7100 scope,
7101 session: None,
7102 });
7103 children.push(RuntimeDragTarget { state, scope });
7104 Self { children }
7105 }
7106 }
7107
7108 impl Widget for RuntimeDragRoot {
7109 fn measure(&mut self, ctx: &mut MeasureCtx, constraints: Constraints) -> Size {
7110 let size = constraints.clamp(Size::new(320.0, 180.0));
7111 self.children
7112 .measure_child(0, ctx, Constraints::tight(Size::new(120.0, 40.0)));
7113 self.children
7114 .measure_child(1, ctx, Constraints::tight(Size::new(120.0, 40.0)));
7115 size
7116 }
7117
7118 fn arrange(&mut self, ctx: &mut ArrangeCtx, bounds: Rect) {
7119 self.children.arrange_child(
7120 0,
7121 ctx,
7122 Rect::new(bounds.x() + 32.0, bounds.y() + 24.0, 120.0, 40.0),
7123 );
7124 self.children.arrange_child(
7125 1,
7126 ctx,
7127 Rect::new(bounds.x() + 172.0, bounds.y() + 24.0, 120.0, 40.0),
7128 );
7129 }
7130
7131 fn visit_children(&self, visitor: &mut dyn WidgetPodVisitor) {
7132 self.children.visit_children(visitor);
7133 }
7134
7135 fn visit_children_mut(&mut self, visitor: &mut dyn WidgetPodMutVisitor) {
7136 self.children.visit_children_mut(visitor);
7137 }
7138 }
7139
7140 impl Widget for HoverTransitionLeaf {
7141 fn event(&mut self, ctx: &mut EventCtx, event: &Event) {
7142 let Event::Pointer(pointer) = event else {
7143 return;
7144 };
7145
7146 let mut state = self.state.borrow_mut();
7147 match pointer.kind {
7148 PointerEventKind::Enter => {
7149 state.enters += 1;
7150 state.hovered = true;
7151 ctx.request_paint();
7152 ctx.request_semantics();
7153 }
7154 PointerEventKind::Leave => {
7155 state.leaves += 1;
7156 state.hovered = false;
7157 ctx.request_paint();
7158 ctx.request_semantics();
7159 }
7160 _ => {}
7161 }
7162 }
7163
7164 fn measure(&mut self, _ctx: &mut MeasureCtx, constraints: Constraints) -> Size {
7165 constraints.clamp(Size::new(120.0, 40.0))
7166 }
7167
7168 fn paint(&self, ctx: &mut PaintCtx) {
7169 let color = if self.state.borrow().hovered {
7170 Color::rgba(0.28, 0.45, 0.68, 1.0)
7171 } else {
7172 Color::rgba(0.20, 0.28, 0.38, 1.0)
7173 };
7174 ctx.fill_bounds(color);
7175 }
7176
7177 fn semantics(&self, ctx: &mut SemanticsCtx) {
7178 let mut node = SemanticsNode::new(ctx.widget_id(), SemanticsRole::Button, ctx.bounds());
7179 node.name = Some(self.name.to_string());
7180 node.state.hovered = self.state.borrow().hovered;
7181 ctx.push(node);
7182 }
7183 }
7184
7185 #[derive(Default)]
7186 struct WakeState {
7187 timer_token: Option<TimerToken>,
7188 async_token: Option<AsyncWakeToken>,
7189 timer_wakes: usize,
7190 async_wakes: usize,
7191 }
7192
7193 struct WakeLeaf {
7194 state: Rc<RefCell<WakeState>>,
7195 }
7196
7197 impl Widget for WakeLeaf {
7198 fn event(&mut self, ctx: &mut EventCtx, event: &Event) {
7199 match event {
7200 Event::Pointer(pointer) if pointer.kind == PointerEventKind::Down => {
7201 let mut state = self.state.borrow_mut();
7202 state.timer_token = Some(ctx.schedule_timer_after(3.0));
7203 state.async_token = Some(ctx.register_async_wakeup());
7204 ctx.set_handled();
7205 }
7206 Event::Wake(WakeEvent::Timer { token, .. }) => {
7207 let mut state = self.state.borrow_mut();
7208 if state.timer_token == Some(*token) {
7209 state.timer_wakes += 1;
7210 ctx.request_paint();
7211 ctx.set_handled();
7212 }
7213 }
7214 Event::Wake(WakeEvent::Async { token, .. }) => {
7215 let mut state = self.state.borrow_mut();
7216 if state.async_token == Some(*token) {
7217 state.async_wakes += 1;
7218 ctx.request_paint();
7219 ctx.set_handled();
7220 }
7221 }
7222 _ => {}
7223 }
7224 }
7225
7226 fn measure(&mut self, _ctx: &mut MeasureCtx, constraints: Constraints) -> Size {
7227 constraints.clamp(Size::new(120.0, 40.0))
7228 }
7229 }
7230
7231 #[derive(Default)]
7232 struct AnimationWakeState {
7233 request_twice: bool,
7234 animation_wakes: usize,
7235 last_animation_time: Option<f64>,
7236 last_animation_delta: Option<f64>,
7237 last_animation_frame_index: Option<u64>,
7238 }
7239
7240 struct AnimationWakeLeaf {
7241 state: Rc<RefCell<AnimationWakeState>>,
7242 }
7243
7244 impl Widget for AnimationWakeLeaf {
7245 fn event(&mut self, ctx: &mut EventCtx, event: &Event) {
7246 match event {
7247 Event::Pointer(pointer) if pointer.kind == PointerEventKind::Down => {
7248 let request_twice = self.state.borrow().request_twice;
7249 ctx.request_animation_frame();
7250 if request_twice {
7251 ctx.request_animation_frame();
7252 }
7253 ctx.set_handled();
7254 }
7255 Event::Wake(WakeEvent::AnimationFrame {
7256 time,
7257 delta,
7258 frame_index,
7259 }) => {
7260 let mut state = self.state.borrow_mut();
7261 state.animation_wakes += 1;
7262 state.last_animation_time = Some(*time);
7263 state.last_animation_delta = Some(*delta);
7264 state.last_animation_frame_index = Some(*frame_index);
7265 ctx.request_paint();
7266 ctx.set_handled();
7267 }
7268 _ => {}
7269 }
7270 }
7271
7272 fn measure(&mut self, _ctx: &mut MeasureCtx, constraints: Constraints) -> Size {
7273 constraints.clamp(Size::new(120.0, 40.0))
7274 }
7275 }
7276
7277 struct AnimationWakeCapturingRoot {
7278 child: SingleChild,
7279 ancestor_wakes: Rc<RefCell<usize>>,
7280 }
7281
7282 impl Widget for AnimationWakeCapturingRoot {
7283 fn event(&mut self, ctx: &mut EventCtx, event: &Event) {
7284 if matches!(event, Event::Wake(WakeEvent::AnimationFrame { .. })) {
7285 *self.ancestor_wakes.borrow_mut() += 1;
7286 ctx.set_handled();
7287 }
7288 }
7289
7290 fn measure(&mut self, ctx: &mut MeasureCtx, constraints: Constraints) -> Size {
7291 let size = constraints.clamp(Size::new(320.0, 180.0));
7292 self.child
7293 .measure(ctx, Constraints::tight(Size::new(120.0, 40.0)));
7294 size
7295 }
7296
7297 fn arrange(&mut self, ctx: &mut ArrangeCtx, bounds: Rect) {
7298 self.child.arrange(
7299 ctx,
7300 Rect::new(bounds.x() + 32.0, bounds.y() + 24.0, 120.0, 40.0),
7301 );
7302 }
7303
7304 fn visit_children(&self, visitor: &mut dyn WidgetPodVisitor) {
7305 self.child.visit_children(visitor);
7306 }
7307
7308 fn visit_children_mut(&mut self, visitor: &mut dyn WidgetPodMutVisitor) {
7309 self.child.visit_children_mut(visitor);
7310 }
7311 }
7312
7313 struct RemovableAnimationRoot {
7314 child: Option<SingleChild>,
7315 }
7316
7317 impl Widget for RemovableAnimationRoot {
7318 fn event(&mut self, ctx: &mut EventCtx, event: &Event) {
7319 if let Event::Custom(custom) = event
7320 && custom.kind == "drop-animation-child"
7321 {
7322 self.child = None;
7323 ctx.request_measure();
7324 ctx.set_handled();
7325 }
7326 }
7327
7328 fn measure(&mut self, ctx: &mut MeasureCtx, constraints: Constraints) -> Size {
7329 let size = constraints.clamp(Size::new(320.0, 180.0));
7330 if let Some(child) = &mut self.child {
7331 child.measure(ctx, Constraints::tight(Size::new(120.0, 40.0)));
7332 }
7333 size
7334 }
7335
7336 fn arrange(&mut self, ctx: &mut ArrangeCtx, bounds: Rect) {
7337 if let Some(child) = &mut self.child {
7338 child.arrange(
7339 ctx,
7340 Rect::new(bounds.x() + 32.0, bounds.y() + 24.0, 120.0, 40.0),
7341 );
7342 }
7343 }
7344
7345 fn visit_children(&self, visitor: &mut dyn WidgetPodVisitor) {
7346 if let Some(child) = &self.child {
7347 child.visit_children(visitor);
7348 }
7349 }
7350
7351 fn visit_children_mut(&mut self, visitor: &mut dyn WidgetPodMutVisitor) {
7352 if let Some(child) = &mut self.child {
7353 child.visit_children_mut(visitor);
7354 }
7355 }
7356 }
7357
7358 struct TextImeLeaf {
7359 layout: RefCell<Option<PersistentTextLayout>>,
7360 }
7361
7362 struct FocusedImeLeaf;
7363
7364 impl Widget for FocusedImeLeaf {
7365 fn measure(&mut self, _ctx: &mut MeasureCtx, constraints: Constraints) -> Size {
7366 constraints.clamp(Size::new(160.0, 32.0))
7367 }
7368
7369 fn paint(&self, ctx: &mut PaintCtx) {
7370 if ctx.is_focused() {
7371 ctx.set_ime_composition_rect(Rect::new(
7372 ctx.bounds().x() + 8.0,
7373 ctx.bounds().y() + 8.0,
7374 1.0,
7375 16.0,
7376 ));
7377 }
7378 }
7379
7380 fn semantics(&self, ctx: &mut SemanticsCtx) {
7381 let mut node =
7382 SemanticsNode::new(ctx.widget_id(), SemanticsRole::TextInput, ctx.bounds());
7383 node.state.focused = ctx.is_focused();
7384 node.actions = vec![SemanticsAction::Focus];
7385 ctx.push(node);
7386 }
7387
7388 fn accepts_focus(&self) -> bool {
7389 true
7390 }
7391 }
7392
7393 impl Widget for TextImeLeaf {
7394 fn measure(&mut self, ctx: &mut MeasureCtx, constraints: Constraints) -> Size {
7395 let size = constraints.clamp(Size::new(160.0, 32.0));
7396 let layout = ctx
7397 .layout()
7398 .shape_text_persistent(None, "compose", size, TextStyle::new(Color::WHITE))
7399 .unwrap();
7400 *self.layout.borrow_mut() = Some(layout);
7401 size
7402 }
7403
7404 fn paint(&self, ctx: &mut PaintCtx) {
7405 let layout = self.layout.borrow();
7406 let layout = layout
7407 .as_ref()
7408 .expect("measure pass should shape text first");
7409 let origin = ctx.bounds().origin;
7410 ctx.draw_persistent_text_layout(origin, layout);
7411 ctx.set_ime_composition_rect(layout.caret_rect(3).translate(origin.to_vector()));
7412 }
7413
7414 fn accepts_focus(&self) -> bool {
7415 true
7416 }
7417 }
7418
7419 struct ChildRoot<W> {
7420 child: SingleChild,
7421 _marker: std::marker::PhantomData<W>,
7422 }
7423
7424 impl<W> ChildRoot<W> {
7425 fn new(child: W) -> Self
7426 where
7427 W: Widget + 'static,
7428 {
7429 Self {
7430 child: SingleChild::new(child),
7431 _marker: std::marker::PhantomData,
7432 }
7433 }
7434 }
7435
7436 impl<W> Widget for ChildRoot<W>
7437 where
7438 W: Widget + 'static,
7439 {
7440 fn measure(&mut self, ctx: &mut MeasureCtx, constraints: Constraints) -> Size {
7441 let size = constraints.clamp(Size::new(320.0, 180.0));
7442 self.child
7443 .measure(ctx, Constraints::tight(Size::new(120.0, 40.0)));
7444 size
7445 }
7446
7447 fn arrange(&mut self, ctx: &mut ArrangeCtx, bounds: Rect) {
7448 self.child.arrange(
7449 ctx,
7450 Rect::new(bounds.x() + 32.0, bounds.y() + 24.0, 120.0, 40.0),
7451 );
7452 }
7453
7454 fn semantics(&self, ctx: &mut SemanticsCtx) {
7455 self.child.semantics(ctx);
7456 }
7457
7458 fn visit_children(&self, visitor: &mut dyn WidgetPodVisitor) {
7459 self.child.visit_children(visitor);
7460 }
7461
7462 fn visit_children_mut(&mut self, visitor: &mut dyn WidgetPodMutVisitor) {
7463 self.child.visit_children_mut(visitor);
7464 }
7465 }
7466
7467 struct PaintedChildRoot<W> {
7468 child: SingleChild,
7469 _marker: std::marker::PhantomData<W>,
7470 }
7471
7472 impl<W> PaintedChildRoot<W> {
7473 fn new(child: W) -> Self
7474 where
7475 W: Widget + 'static,
7476 {
7477 Self {
7478 child: SingleChild::new(child),
7479 _marker: std::marker::PhantomData,
7480 }
7481 }
7482 }
7483
7484 impl<W> Widget for PaintedChildRoot<W>
7485 where
7486 W: Widget + 'static,
7487 {
7488 fn measure(&mut self, ctx: &mut MeasureCtx, constraints: Constraints) -> Size {
7489 let size = constraints.clamp(Size::new(320.0, 180.0));
7490 self.child
7491 .measure(ctx, Constraints::tight(Size::new(160.0, 32.0)));
7492 size
7493 }
7494
7495 fn arrange(&mut self, ctx: &mut ArrangeCtx, bounds: Rect) {
7496 self.child.arrange(
7497 ctx,
7498 Rect::new(bounds.x() + 32.0, bounds.y() + 24.0, 160.0, 32.0),
7499 );
7500 }
7501
7502 fn paint(&self, ctx: &mut PaintCtx) {
7503 self.child.paint(ctx);
7504 }
7505
7506 fn semantics(&self, ctx: &mut SemanticsCtx) {
7507 self.child.semantics(ctx);
7508 }
7509
7510 fn visit_children(&self, visitor: &mut dyn WidgetPodVisitor) {
7511 self.child.visit_children(visitor);
7512 }
7513
7514 fn visit_children_mut(&mut self, visitor: &mut dyn WidgetPodMutVisitor) {
7515 self.child.visit_children_mut(visitor);
7516 }
7517 }
7518
7519 fn build_runtime() -> (
7520 Runtime,
7521 sui_core::WindowId,
7522 Rc<RefCell<Counters>>,
7523 Rc<RefCell<Counters>>,
7524 ) {
7525 let root_counters = Rc::new(RefCell::new(Counters::default()));
7526 let leaf_counters = Rc::new(RefCell::new(Counters::default()));
7527
7528 let runtime = Application::new()
7529 .window(WindowBuilder::new().title("Test").root(TestRoot {
7530 counters: Rc::clone(&root_counters),
7531 child: SingleChild::new(FocusLeaf {
7532 counters: Rc::clone(&leaf_counters),
7533 }),
7534 }))
7535 .build()
7536 .unwrap();
7537
7538 let window_id = runtime.window_ids()[0];
7539 (runtime, window_id, root_counters, leaf_counters)
7540 }
7541
7542 fn build_semantics_action_runtime() -> (
7543 Runtime,
7544 sui_core::WindowId,
7545 Rc<RefCell<SemanticActionState>>,
7546 ) {
7547 let state = Rc::new(RefCell::new(SemanticActionState::default()));
7548 let runtime = Application::new()
7549 .window(
7550 WindowBuilder::new()
7551 .title("Semantic Actions")
7552 .root(PaintedChildRoot::new(SyntheticSemanticActionLeaf {
7553 state: Rc::clone(&state),
7554 })),
7555 )
7556 .build()
7557 .unwrap();
7558 let window_id = runtime.window_ids()[0];
7559 (runtime, window_id, state)
7560 }
7561
7562 #[test]
7563 fn window_builder_uses_default_sui_icon() {
7564 let (runtime, window_id, _, _) = build_runtime();
7565
7566 let icon = runtime.window_icon(window_id).unwrap().unwrap();
7567 assert!(matches!(icon, WindowIcon::Svg { .. }));
7568 assert!(
7569 std::str::from_utf8(icon.as_svg().unwrap())
7570 .unwrap()
7571 .contains("SUI logo")
7572 );
7573 }
7574
7575 #[test]
7576 fn window_builder_can_override_or_disable_icon() {
7577 let override_icon = WindowIcon::from_svg("<svg viewBox=\"0 0 1 1\"></svg>");
7578 let runtime = Application::new()
7579 .window(
7580 WindowBuilder::new()
7581 .title("Custom icon")
7582 .icon(override_icon.clone())
7583 .root(FocusLeaf {
7584 counters: Rc::new(RefCell::new(Counters::default())),
7585 }),
7586 )
7587 .window(
7588 WindowBuilder::new()
7589 .title("No icon")
7590 .without_icon()
7591 .root(FocusLeaf {
7592 counters: Rc::new(RefCell::new(Counters::default())),
7593 }),
7594 )
7595 .build()
7596 .unwrap();
7597
7598 let window_ids = runtime.window_ids();
7599 assert_eq!(
7600 runtime.window_icon(window_ids[0]).unwrap(),
7601 Some(&override_icon)
7602 );
7603 assert_eq!(runtime.window_icon(window_ids[1]).unwrap(), None);
7604 }
7605
7606 #[test]
7607 fn independent_runtimes_allocate_distinct_window_ids() {
7608 let first = Application::new()
7609 .window(WindowBuilder::new().title("First").root(FocusLeaf {
7610 counters: Rc::new(RefCell::new(Counters::default())),
7611 }))
7612 .build()
7613 .unwrap();
7614 let second = Application::new()
7615 .window(WindowBuilder::new().title("Second").root(FocusLeaf {
7616 counters: Rc::new(RefCell::new(Counters::default())),
7617 }))
7618 .build()
7619 .unwrap();
7620
7621 assert_ne!(first.window_ids()[0], second.window_ids()[0]);
7622 }
7623
7624 #[test]
7625 fn rgba_window_icon_validates_buffer_shape() {
7626 assert!(WindowIcon::from_rgba8(1, 1, vec![0, 0, 0, 255]).is_ok());
7627 assert!(WindowIcon::from_rgba8(0, 1, Vec::new()).is_err());
7628 assert!(WindowIcon::from_rgba8(1, 1, vec![0, 0, 0]).is_err());
7629 }
7630
7631 fn build_cached_move_runtime() -> (
7632 Runtime,
7633 sui_core::WindowId,
7634 Rc<RefCell<Counters>>,
7635 Rc<RefCell<Counters>>,
7636 ) {
7637 let root_counters = Rc::new(RefCell::new(Counters::default()));
7638 let leaf_counters = Rc::new(RefCell::new(Counters::default()));
7639 let presentation = Rc::new(RefCell::new(CachedLayerPresentation::default()));
7640
7641 let runtime = Application::new()
7642 .window(
7643 WindowBuilder::new()
7644 .title("Cached move")
7645 .root(CachedMoveRoot {
7646 counters: Rc::clone(&root_counters),
7647 child: SingleChild::new(CachedMoveLeaf {
7648 counters: Rc::clone(&leaf_counters),
7649 presentation: Rc::clone(&presentation),
7650 }),
7651 presentation,
7652 offset_x: 0.0,
7653 paint_background: true,
7654 }),
7655 )
7656 .build()
7657 .unwrap();
7658
7659 let window_id = runtime.window_ids()[0];
7660 (runtime, window_id, root_counters, leaf_counters)
7661 }
7662
7663 fn build_direct_move_runtime() -> (
7664 Runtime,
7665 sui_core::WindowId,
7666 Rc<RefCell<Counters>>,
7667 Rc<RefCell<Counters>>,
7668 ) {
7669 let root_counters = Rc::new(RefCell::new(Counters::default()));
7670 let leaf_counters = Rc::new(RefCell::new(Counters::default()));
7671
7672 let runtime = Application::new()
7673 .window(
7674 WindowBuilder::new()
7675 .title("Direct move")
7676 .root(DirectMoveRoot {
7677 counters: Rc::clone(&root_counters),
7678 child: SingleChild::new(DirectMoveLeaf {
7679 counters: Rc::clone(&leaf_counters),
7680 }),
7681 offset_x: 0.0,
7682 }),
7683 )
7684 .build()
7685 .unwrap();
7686
7687 let window_id = runtime.window_ids()[0];
7688 (runtime, window_id, root_counters, leaf_counters)
7689 }
7690
7691 fn build_overpaint_runtime() -> (Runtime, sui_core::WindowId) {
7692 let runtime = Application::new()
7693 .window(WindowBuilder::new().title("Overpaint").root(TestRoot {
7694 counters: Rc::new(RefCell::new(Counters::default())),
7695 child: SingleChild::new(OverpaintLeaf {
7696 size: Size::new(120.0, 40.0),
7697 color: Color::rgba(0.92, 0.42, 0.18, 1.0),
7698 bleed: Vector::new(6.0, 4.0),
7699 }),
7700 }))
7701 .build()
7702 .unwrap();
7703
7704 let window_id = runtime.window_ids()[0];
7705 (runtime, window_id)
7706 }
7707
7708 fn build_focus_traversal_runtime() -> (
7709 Runtime,
7710 sui_core::WindowId,
7711 Rc<RefCell<Counters>>,
7712 Rc<RefCell<Counters>>,
7713 ) {
7714 let first = Rc::new(RefCell::new(Counters::default()));
7715 let second = Rc::new(RefCell::new(Counters::default()));
7716
7717 let runtime =
7718 Application::new()
7719 .window(WindowBuilder::new().title("Focus Traversal").root(
7720 FocusTraversalRoot::new(Rc::clone(&first), Rc::clone(&second)),
7721 ))
7722 .build()
7723 .unwrap();
7724
7725 let window_id = runtime.window_ids()[0];
7726 (runtime, window_id, first, second)
7727 }
7728
7729 fn graph_child(graph: &WidgetGraphSnapshot) -> &WidgetNodeSnapshot {
7730 &graph.nodes[1]
7731 }
7732
7733 fn scene_has_layer_for(scene: &sui_scene::Scene, widget_id: sui_core::WidgetId) -> bool {
7734 scene.commands().iter().any(|command| match command {
7735 SceneCommand::Layer(layer) => layer.widget_id() == widget_id,
7736 _ => false,
7737 })
7738 }
7739
7740 fn build_pointer_capture_runtime() -> (
7741 Runtime,
7742 sui_core::WindowId,
7743 Rc<RefCell<PointerCaptureState>>,
7744 ) {
7745 let state = Rc::new(RefCell::new(PointerCaptureState::default()));
7746
7747 let runtime = Application::new()
7748 .window(
7749 WindowBuilder::new()
7750 .title("Pointer Capture")
7751 .root(ChildRoot::new(PointerCaptureLeaf {
7752 state: Rc::clone(&state),
7753 recapture_on_move: false,
7754 })),
7755 )
7756 .build()
7757 .unwrap();
7758
7759 let window_id = runtime.window_ids()[0];
7760 (runtime, window_id, state)
7761 }
7762
7763 fn build_hover_transition_runtime() -> (
7764 Runtime,
7765 sui_core::WindowId,
7766 Rc<RefCell<HoverTransitionState>>,
7767 Rc<RefCell<HoverTransitionState>>,
7768 ) {
7769 let first = Rc::new(RefCell::new(HoverTransitionState::default()));
7770 let second = Rc::new(RefCell::new(HoverTransitionState::default()));
7771
7772 let runtime =
7773 Application::new()
7774 .window(WindowBuilder::new().title("Hover transitions").root(
7775 HoverTransitionRoot::new(Rc::clone(&first), Rc::clone(&second)),
7776 ))
7777 .build()
7778 .unwrap();
7779
7780 let window_id = runtime.window_ids()[0];
7781 (runtime, window_id, first, second)
7782 }
7783
7784 fn build_wake_runtime() -> (Runtime, sui_core::WindowId, Rc<RefCell<WakeState>>) {
7785 let state = Rc::new(RefCell::new(WakeState::default()));
7786
7787 let runtime = Application::new()
7788 .window(
7789 WindowBuilder::new()
7790 .title("Wake")
7791 .root(ChildRoot::new(WakeLeaf {
7792 state: Rc::clone(&state),
7793 })),
7794 )
7795 .build()
7796 .unwrap();
7797
7798 let window_id = runtime.window_ids()[0];
7799 (runtime, window_id, state)
7800 }
7801
7802 fn build_animation_wake_runtime(
7803 request_twice: bool,
7804 ) -> (Runtime, sui_core::WindowId, Rc<RefCell<AnimationWakeState>>) {
7805 let state = Rc::new(RefCell::new(AnimationWakeState {
7806 request_twice,
7807 ..AnimationWakeState::default()
7808 }));
7809
7810 let runtime = Application::new()
7811 .window(
7812 WindowBuilder::new()
7813 .title("Animation Wake")
7814 .root(ChildRoot::new(AnimationWakeLeaf {
7815 state: Rc::clone(&state),
7816 })),
7817 )
7818 .build()
7819 .unwrap();
7820
7821 let window_id = runtime.window_ids()[0];
7822 (runtime, window_id, state)
7823 }
7824
7825 fn build_removable_animation_runtime() -> (Runtime, sui_core::WindowId) {
7826 let state = Rc::new(RefCell::new(AnimationWakeState::default()));
7827 let runtime = Application::new()
7828 .window(WindowBuilder::new().title("Removable Animation").root(
7829 RemovableAnimationRoot {
7830 child: Some(SingleChild::new(AnimationWakeLeaf { state })),
7831 },
7832 ))
7833 .build()
7834 .unwrap();
7835
7836 let window_id = runtime.window_ids()[0];
7837 (runtime, window_id)
7838 }
7839
7840 fn build_text_runtime() -> (Runtime, sui_core::WindowId) {
7841 let runtime = Application::new()
7842 .window(
7843 WindowBuilder::new()
7844 .title("Text")
7845 .root(PaintedChildRoot::new(TextImeLeaf {
7846 layout: RefCell::new(None),
7847 })),
7848 )
7849 .build()
7850 .unwrap();
7851
7852 let window_id = runtime.window_ids()[0];
7853 (runtime, window_id)
7854 }
7855
7856 #[test]
7857 fn runtime_exposes_retained_widget_graph() {
7858 let (mut runtime, window_id, _, _) = build_runtime();
7859
7860 let output = runtime.render(window_id).unwrap();
7861 let graph = runtime.widget_graph(window_id).unwrap();
7862
7863 assert_eq!(graph.nodes.len(), 2);
7864 assert_eq!(graph.nodes[0].id, graph.root);
7865 assert_eq!(graph.nodes[0].stack_host, graph.root);
7866 assert!(graph.nodes[0].is_stack_host);
7867 assert_eq!(graph_child(&graph).parent, Some(graph.root));
7868 assert_eq!(graph_child(&graph).stack_host, graph.root);
7869 assert!(!graph_child(&graph).is_stack_surface);
7870 assert_eq!(graph.stack_hosts.len(), 1);
7871 assert_eq!(graph.stack_hosts[0].host, graph.root);
7872 assert!(graph.stack_hosts[0].surfaces.is_empty());
7873 assert!(graph_child(&graph).accepts_focus);
7874 assert_eq!(
7875 graph_child(&graph).geometry.layout_bounds,
7876 graph_child(&graph).bounds
7877 );
7878 assert_eq!(
7879 graph_child(&graph).geometry.input_bounds,
7880 graph_child(&graph).geometry.layout_bounds
7881 );
7882 assert_eq!(
7883 graph_child(&graph).geometry.paint_bounds,
7884 graph_child(&graph).geometry.layout_bounds
7885 );
7886 assert_eq!(output.frame.viewport, Size::new(320.0, 180.0));
7887 assert_eq!(output.frame.surface_size, Size::new(320.0, 180.0));
7888 assert_eq!(output.frame.scale_factor, 1.0);
7889 }
7890
7891 #[test]
7892 fn synthetic_semantic_activate_falls_back_to_pointer_routing() {
7893 let (mut runtime, window_id, state) = build_semantics_action_runtime();
7894 let _ = runtime.render(window_id).unwrap();
7895
7896 assert!(
7897 runtime
7898 .handle_semantics_action(
7899 window_id,
7900 SYNTHETIC_ACTION_ID,
7901 SemanticsActionRequest::Activate,
7902 )
7903 .unwrap()
7904 );
7905
7906 let state = state.borrow();
7907 assert_eq!(
7908 state.actions,
7909 vec![(SYNTHETIC_ACTION_ID, SemanticsActionRequest::Activate)]
7910 );
7911 assert_eq!(state.pointer_activations, 1);
7912 }
7913
7914 #[test]
7915 fn semantic_expand_and_collapse_use_idempotent_pointer_fallbacks() {
7916 let (mut runtime, window_id, state) = build_semantics_action_runtime();
7917 let _ = runtime.render(window_id).unwrap();
7918
7919 assert!(
7920 runtime
7921 .handle_semantics_action(
7922 window_id,
7923 SYNTHETIC_ACTION_ID,
7924 SemanticsActionRequest::Expand,
7925 )
7926 .unwrap()
7927 );
7928 assert!(state.borrow().expanded);
7929 assert_eq!(state.borrow().pointer_activations, 1);
7930
7931 let _ = runtime.render(window_id).unwrap();
7932 assert!(
7933 runtime
7934 .handle_semantics_action(
7935 window_id,
7936 SYNTHETIC_ACTION_ID,
7937 SemanticsActionRequest::Expand,
7938 )
7939 .unwrap()
7940 );
7941 assert_eq!(state.borrow().pointer_activations, 1);
7942
7943 assert!(
7944 runtime
7945 .handle_semantics_action(
7946 window_id,
7947 SYNTHETIC_ACTION_ID,
7948 SemanticsActionRequest::Collapse,
7949 )
7950 .unwrap()
7951 );
7952 assert!(!state.borrow().expanded);
7953 assert_eq!(state.borrow().pointer_activations, 2);
7954 }
7955
7956 #[test]
7957 fn synthetic_semantic_focus_targets_graph_owner_and_retains_semantic_identity() {
7958 let (mut runtime, window_id, state) = build_semantics_action_runtime();
7959 let first = runtime.render(window_id).unwrap();
7960 let owner_id = first
7961 .semantics
7962 .iter()
7963 .find(|node| node.name.as_deref() == Some("semantic action owner"))
7964 .unwrap()
7965 .id;
7966
7967 assert!(
7968 runtime
7969 .handle_semantics_action(
7970 window_id,
7971 SYNTHETIC_ACTION_ID,
7972 SemanticsActionRequest::Focus,
7973 )
7974 .unwrap()
7975 );
7976 assert_eq!(runtime.focused_widget(window_id).unwrap(), Some(owner_id));
7977
7978 let focused = runtime.render(window_id).unwrap();
7979 assert!(
7980 focused
7981 .semantics
7982 .iter()
7983 .find(|node| node.id == SYNTHETIC_ACTION_ID)
7984 .unwrap()
7985 .state
7986 .focused
7987 );
7988 assert_eq!(
7989 state.borrow().actions,
7990 vec![(SYNTHETIC_ACTION_ID, SemanticsActionRequest::Focus)]
7991 );
7992
7993 let mut pointer = PointerEvent::new(PointerEventKind::Down, Point::new(48.0, 32.0));
7994 pointer.button = Some(PointerButton::Primary);
7995 pointer.buttons.insert(PointerButton::Primary);
7996 runtime
7997 .handle_event(window_id, Event::Pointer(pointer))
7998 .unwrap();
7999 let pointer_focused = runtime.render(window_id).unwrap();
8000 assert!(
8001 pointer_focused
8002 .semantics
8003 .iter()
8004 .find(|node| node.id == owner_id)
8005 .unwrap()
8006 .state
8007 .focused
8008 );
8009 assert!(
8010 !pointer_focused
8011 .semantics
8012 .iter()
8013 .find(|node| node.id == SYNTHETIC_ACTION_ID)
8014 .unwrap()
8015 .state
8016 .focused
8017 );
8018 }
8019
8020 #[test]
8021 fn semantic_blur_only_clears_the_current_semantic_focus_target() {
8022 let (mut runtime, window_id, _state) = build_semantics_action_runtime();
8023 let _ = runtime.render(window_id).unwrap();
8024
8025 assert!(
8026 !runtime
8027 .handle_semantics_action(
8028 window_id,
8029 SYNTHETIC_ACTION_ID,
8030 SemanticsActionRequest::Blur,
8031 )
8032 .unwrap()
8033 );
8034 assert!(
8035 runtime
8036 .handle_semantics_action(
8037 window_id,
8038 SYNTHETIC_ACTION_ID,
8039 SemanticsActionRequest::Focus,
8040 )
8041 .unwrap()
8042 );
8043 assert!(
8044 runtime
8045 .handle_semantics_action(
8046 window_id,
8047 SYNTHETIC_ACTION_ID,
8048 SemanticsActionRequest::Blur,
8049 )
8050 .unwrap()
8051 );
8052 assert_eq!(runtime.focused_widget(window_id).unwrap(), None);
8053 }
8054
8055 #[test]
8056 fn semantic_focus_rejects_an_unhandled_target_without_a_focusable_owner() {
8057 let mut runtime = Application::new()
8058 .window(
8059 WindowBuilder::new()
8060 .title("Unfocusable Semantic Action")
8061 .root(ChildRoot::new(UnfocusableSemanticLeaf)),
8062 )
8063 .build()
8064 .unwrap();
8065 let window_id = runtime.window_ids()[0];
8066 let output = runtime.render(window_id).unwrap();
8067 let target = output
8068 .semantics
8069 .iter()
8070 .find(|node| node.name.as_deref() == Some("unfocusable semantic node"))
8071 .unwrap()
8072 .id;
8073
8074 assert!(
8075 !runtime
8076 .handle_semantics_action(window_id, target, SemanticsActionRequest::Focus,)
8077 .unwrap()
8078 );
8079 assert_eq!(runtime.focused_widget(window_id).unwrap(), None);
8080 assert!(
8081 !runtime
8082 .render(window_id)
8083 .unwrap()
8084 .semantics
8085 .iter()
8086 .find(|node| node.id == target)
8087 .unwrap()
8088 .state
8089 .focused
8090 );
8091 }
8092
8093 #[test]
8094 fn stale_disabled_and_unadvertised_semantic_actions_are_rejected() {
8095 let (mut stale_runtime, stale_window_id, stale_state) = build_semantics_action_runtime();
8096 let _ = stale_runtime.render(stale_window_id).unwrap();
8097
8098 assert!(
8099 !stale_runtime
8100 .handle_semantics_action(
8101 stale_window_id,
8102 WidgetId::new(u64::MAX - 2),
8103 SemanticsActionRequest::Activate,
8104 )
8105 .unwrap()
8106 );
8107 assert!(
8108 !stale_runtime
8109 .handle_semantics_action(
8110 stale_window_id,
8111 SYNTHETIC_ACTION_ID,
8112 SemanticsActionRequest::Increment,
8113 )
8114 .unwrap()
8115 );
8116 assert!(stale_state.borrow().actions.is_empty());
8117
8118 let (mut disabled_runtime, disabled_window_id, disabled_state) =
8119 build_semantics_action_runtime();
8120 disabled_state.borrow_mut().disabled = true;
8121 let _ = disabled_runtime.render(disabled_window_id).unwrap();
8122 assert!(
8123 !disabled_runtime
8124 .handle_semantics_action(
8125 disabled_window_id,
8126 SYNTHETIC_ACTION_ID,
8127 SemanticsActionRequest::Activate,
8128 )
8129 .unwrap()
8130 );
8131 assert!(disabled_state.borrow().actions.is_empty());
8132 }
8133
8134 #[test]
8135 fn semantic_action_payload_is_typed_and_unsupported_actions_are_rejected() {
8136 let (mut runtime, window_id, state) = build_semantics_action_runtime();
8137 let _ = runtime.render(window_id).unwrap();
8138
8139 let set_value_handled = runtime
8140 .handle_semantics_action(
8141 window_id,
8142 SYNTHETIC_ACTION_ID,
8143 SemanticsActionRequest::SetValue(SemanticsValue::Text("forty two".into())),
8144 )
8145 .unwrap();
8146 assert!(
8147 set_value_handled,
8148 "state after SetValue: {:?}; semantics: {:?}; graph: {:?}",
8149 state.borrow(),
8150 runtime.semantics(window_id).unwrap(),
8151 runtime.widget_graph(window_id).unwrap()
8152 );
8153 assert!(
8154 runtime
8155 .handle_semantics_action(
8156 window_id,
8157 SYNTHETIC_ACTION_ID,
8158 SemanticsActionRequest::InsertText("hello".into()),
8159 )
8160 .unwrap()
8161 );
8162 assert!(
8163 !runtime
8164 .handle_semantics_action(
8165 window_id,
8166 SYNTHETIC_ACTION_ID,
8167 SemanticsActionRequest::Increment,
8168 )
8169 .unwrap()
8170 );
8171
8172 assert_eq!(
8173 state.borrow().actions,
8174 vec![
8175 (
8176 SYNTHETIC_ACTION_ID,
8177 SemanticsActionRequest::SetValue(SemanticsValue::Text("forty two".into())),
8178 ),
8179 (
8180 SYNTHETIC_ACTION_ID,
8181 SemanticsActionRequest::InsertText("hello".into()),
8182 ),
8183 ]
8184 );
8185 }
8186
8187 #[test]
8188 fn render_output_is_send_sync() {
8189 fn assert_send_sync<T: Send + Sync>() {}
8190
8191 assert_send_sync::<RenderOutput>();
8192 }
8193
8194 #[test]
8195 fn widget_graph_visits_logical_children_even_when_paint_is_virtualized() {
8196 let paint_state = Rc::new(RefCell::new(VirtualizedPaintState::default()));
8197 let mut runtime = Application::new()
8198 .window(
8199 WindowBuilder::new()
8200 .title("Virtualized")
8201 .root(VirtualizedLogicalRoot::new(4, 2, Rc::clone(&paint_state))),
8202 )
8203 .build()
8204 .unwrap();
8205 let window_id = runtime.window_ids()[0];
8206
8207 let _ = runtime.render(window_id).unwrap();
8208 let graph = runtime.widget_graph(window_id).unwrap();
8209 let root = graph
8210 .nodes
8211 .iter()
8212 .find(|node| node.id == graph.root)
8213 .unwrap();
8214
8215 assert_eq!(root.children.len(), 4);
8216 assert_eq!(graph.nodes.len(), 5);
8217 assert_eq!(paint_state.borrow().painted, vec![0, 1]);
8218 }
8219
8220 #[test]
8221 fn worker_owned_snapshot_state_reenters_runtime_without_widget_send_sync() {
8222 let local = Rc::new(RefCell::new(ThreadedSnapshotState::default()));
8223 let inbox = Arc::new(Mutex::new(VecDeque::new()));
8224 let mut runtime =
8225 Application::new()
8226 .window(WindowBuilder::new().title("Threaded Snapshot").root(
8227 ThreadedSnapshotRoot {
8228 local: Rc::clone(&local),
8229 inbox: Arc::clone(&inbox),
8230 },
8231 ))
8232 .build()
8233 .unwrap();
8234 let window_id = runtime.window_ids()[0];
8235
8236 let _ = runtime.render(window_id).unwrap();
8237 runtime
8238 .handle_event(
8239 window_id,
8240 Event::Custom(CustomEvent::new("arm-threaded-snapshot")),
8241 )
8242 .unwrap();
8243 let async_token = local.borrow().async_token.unwrap();
8244
8245 let worker_inbox = Arc::clone(&inbox);
8246 std::thread::spawn(move || {
8247 worker_inbox
8248 .lock()
8249 .unwrap()
8250 .push_back("worker-ready".to_string());
8251 })
8252 .join()
8253 .unwrap();
8254
8255 assert!(runtime.wake_async(window_id, async_token).unwrap());
8256 for (ready_window, event) in runtime.drain_ready_events() {
8257 runtime.handle_event(ready_window, event).unwrap();
8258 }
8259
8260 assert_eq!(local.borrow().latest.as_deref(), Some("worker-ready"));
8261 assert!(runtime.needs_render(window_id).unwrap());
8262
8263 let _ = runtime.render(window_id).unwrap();
8264 assert_eq!(local.borrow().paints, 2);
8265 }
8266
8267 struct EventPoster {
8268 log: Rc<RefCell<Vec<String>>>,
8269 }
8270
8271 impl Widget for EventPoster {
8272 fn event(&mut self, ctx: &mut EventCtx, event: &Event) {
8273 if let Event::Custom(custom) = event {
8274 self.log.borrow_mut().push(custom.kind.clone());
8275 if custom.kind == "posted-trigger" {
8276 ctx.post_event(
8277 ctx.widget_id(),
8278 Event::Custom(CustomEvent::new("posted-response")),
8279 );
8280 }
8281 }
8282 }
8283 }
8284
8285 #[test]
8286 fn posted_events_are_delivered_after_the_current_dispatch() {
8287 let log = Rc::new(RefCell::new(Vec::new()));
8288 let mut runtime = Application::new()
8289 .window(WindowBuilder::new().title("Posted").root(EventPoster {
8290 log: Rc::clone(&log),
8291 }))
8292 .build()
8293 .unwrap();
8294 let window_id = runtime.window_ids()[0];
8295 let _ = runtime.render(window_id).unwrap();
8296
8297 runtime
8298 .handle_event(window_id, Event::Custom(CustomEvent::new("posted-trigger")))
8299 .unwrap();
8300
8301 assert_eq!(
8302 log.borrow().as_slice(),
8303 ["posted-trigger".to_string(), "posted-response".to_string()]
8304 );
8305 }
8306
8307 #[test]
8308 fn runtime_clipboard_is_shared_with_window_event_contexts() {
8309 let mut runtime = Application::new()
8310 .window(WindowBuilder::new().title("Clipboard").root(FocusLeaf {
8311 counters: Rc::new(RefCell::new(Counters::default())),
8312 }))
8313 .build()
8314 .unwrap();
8315 let window_id = runtime.window_ids()[0];
8316 let _ = runtime.render(window_id).unwrap();
8317
8318 runtime.clipboard().set_text("shared");
8319 assert_eq!(runtime.clipboard().text().as_deref(), Some("shared"));
8320
8321 runtime.set_clipboard_backend(sui_core::LocalClipboardBackend::new());
8322 assert_eq!(runtime.clipboard().text(), None);
8323 }
8324
8325 #[test]
8326 fn explicit_paint_boundary_direct_child_remains_a_stack_surface() {
8327 let (mut runtime, window_id, _, _) = build_cached_move_runtime();
8328
8329 let _ = runtime.render(window_id).unwrap();
8330 let graph = runtime.widget_graph(window_id).unwrap();
8331 let child = graph_child(&graph);
8332
8333 assert!(child.is_stack_surface);
8334 assert_eq!(graph.stack_hosts.len(), 1);
8335 assert_eq!(graph.stack_hosts[0].host, graph.root);
8336 assert_eq!(graph.stack_hosts[0].surfaces, vec![child.id]);
8337 }
8338
8339 #[test]
8340 fn non_hit_test_stack_surface_allows_underlying_pointer_target() {
8341 let pointer_downs = Rc::new(RefCell::new(0));
8342 let runtime = Application::new()
8343 .window(
8344 WindowBuilder::new()
8345 .title("Overlay pass-through")
8346 .root(OverlayPassThroughRoot::new(Rc::clone(&pointer_downs))),
8347 )
8348 .build()
8349 .unwrap();
8350 let window_id = runtime.window_ids()[0];
8351 let mut runtime = runtime;
8352
8353 let output = runtime.render(window_id).unwrap();
8354 let mut overlay_hit_test = None;
8355 output.frame.scene.visit_layers(&mut |layer| {
8356 if layer.descriptor.composition_mode == LayerCompositionMode::Overlay {
8357 overlay_hit_test = Some(layer.descriptor.hit_test);
8358 }
8359 });
8360 assert_eq!(overlay_hit_test, Some(false));
8361
8362 let mut down = PointerEvent::new(PointerEventKind::Down, Point::new(48.0, 36.0));
8363 down.pointer_id = 1;
8364 down.button = Some(PointerButton::Primary);
8365 down.buttons = PointerButtons::new(1);
8366 runtime
8367 .handle_event(window_id, Event::Pointer(down))
8368 .unwrap();
8369
8370 assert_eq!(*pointer_downs.borrow(), 1);
8371 }
8372
8373 #[test]
8374 fn hit_test_stack_surface_targets_deepest_child() {
8375 let pointer_downs = Rc::new(RefCell::new(0));
8376 let runtime = Application::new()
8377 .window(
8378 WindowBuilder::new()
8379 .title("Overlay child hit")
8380 .root(HitTestOverlayRoot::new(Rc::clone(&pointer_downs))),
8381 )
8382 .build()
8383 .unwrap();
8384 let window_id = runtime.window_ids()[0];
8385 let mut runtime = runtime;
8386
8387 let output = runtime.render(window_id).unwrap();
8388 let mut effect_hit_test = None;
8389 output.frame.scene.visit_layers(&mut |layer| {
8390 if layer.descriptor.composition_mode == LayerCompositionMode::Effect {
8391 effect_hit_test = Some(layer.descriptor.hit_test);
8392 }
8393 });
8394 assert_eq!(effect_hit_test, Some(true));
8395
8396 let mut down = PointerEvent::new(PointerEventKind::Down, Point::new(80.0, 60.0));
8397 down.pointer_id = 1;
8398 down.button = Some(PointerButton::Primary);
8399 down.buttons = PointerButtons::new(1);
8400 runtime
8401 .handle_event(window_id, Event::Pointer(down))
8402 .unwrap();
8403
8404 assert_eq!(*pointer_downs.borrow(), 1);
8405 }
8406
8407 #[test]
8408 fn runtime_reports_surface_size_and_scale_factor_for_hidpi_windows() {
8409 let (mut runtime, window_id, _, _) = build_runtime();
8410
8411 runtime
8412 .handle_event(
8413 window_id,
8414 Event::Window(WindowEvent::ScaleFactorChanged {
8415 scale_factor: 2.0,
8416 raw_dpi: Some(192.0),
8417 suggested_size: Some(Size::new(320.0, 180.0)),
8418 }),
8419 )
8420 .unwrap();
8421
8422 let output = runtime.render(window_id).unwrap();
8423
8424 assert_eq!(output.frame.viewport, Size::new(320.0, 180.0));
8425 assert_eq!(output.frame.surface_size, Size::new(640.0, 360.0));
8426 assert_eq!(output.frame.scale_factor, 2.0);
8427 }
8428
8429 #[test]
8430 fn runtime_delivers_external_file_events_without_changing_window_geometry() {
8431 let events = Rc::new(RefCell::new(Vec::new()));
8432 let mut runtime =
8433 Application::new()
8434 .window(WindowBuilder::new().title("External file events").root(
8435 WindowEventRecorder {
8436 events: Rc::clone(&events),
8437 },
8438 ))
8439 .build()
8440 .unwrap();
8441 let window_id = runtime.window_ids()[0];
8442 let before = runtime.render(window_id).unwrap().frame;
8443 let path = PathBuf::from(r"C:\workspace\agent.json");
8444
8445 for event in [
8446 WindowEvent::ExternalFileHovered(path.clone()),
8447 WindowEvent::ExternalFileDropped(path.clone()),
8448 WindowEvent::ExternalFileHoverCancelled,
8449 ] {
8450 runtime
8451 .handle_event(window_id, Event::Window(event))
8452 .unwrap();
8453 }
8454
8455 assert_eq!(
8456 events.borrow().as_slice(),
8457 &[
8458 WindowEvent::ExternalFileHovered(path.clone()),
8459 WindowEvent::ExternalFileDropped(path),
8460 WindowEvent::ExternalFileHoverCancelled,
8461 ]
8462 );
8463 let after = runtime.render(window_id).unwrap().frame;
8464 assert_eq!(after.viewport, before.viewport);
8465 assert_eq!(after.surface_size, before.surface_size);
8466 assert_eq!(after.scale_factor, before.scale_factor);
8467 }
8468
8469 #[test]
8470 fn runtime_attaches_registered_fonts_to_render_output() {
8471 let (mut runtime, window_id, _, _) = build_runtime();
8472 let handle = FontHandle::new(33);
8473
8474 runtime
8475 .register_font(handle, RegisteredFont::from_bytes(vec![0, 1, 2, 3]))
8476 .unwrap();
8477
8478 let output = runtime.render(window_id).unwrap();
8479
8480 assert!(output.frame.font_registry.contains(handle));
8481 }
8482
8483 #[test]
8484 fn runtime_attaches_registered_images_to_render_output() {
8485 let (mut runtime, window_id, _, _) = build_runtime();
8486 let handle = ImageHandle::new(7);
8487
8488 runtime
8489 .register_image(
8490 handle,
8491 RegisteredImage::from_rgba8(1, 1, vec![255, 0, 0, 255]).unwrap(),
8492 )
8493 .unwrap();
8494
8495 let output = runtime.render(window_id).unwrap();
8496
8497 assert!(output.frame.image_registry.contains(handle));
8498 }
8499
8500 #[test]
8501 fn paint_registered_external_images_are_included_in_render_output() {
8502 struct ExternalImageLeaf {
8503 handle: ImageHandle,
8504 }
8505
8506 impl Widget for ExternalImageLeaf {
8507 fn paint(&self, ctx: &mut PaintCtx) {
8508 ctx.register_external_image(
8509 self.handle,
8510 RegisteredExternalImage::new(640, 360).unwrap(),
8511 );
8512 ctx.draw_image(ctx.bounds(), self.handle);
8513 }
8514 }
8515
8516 let handle = ImageHandle::new(71);
8517 let mut runtime = Application::new()
8518 .window(
8519 WindowBuilder::new()
8520 .title("External image")
8521 .root(ExternalImageLeaf { handle }),
8522 )
8523 .build()
8524 .unwrap();
8525 let window_id = runtime.window_ids()[0];
8526
8527 let output = runtime.render(window_id).unwrap();
8528 assert_eq!(
8529 output.frame.image_registry.dimensions(handle),
8530 Some((640, 360))
8531 );
8532 assert!(output.frame.image_registry.get(handle).is_none());
8533 assert!(output.frame.image_registry.get_external(handle).is_some());
8534 }
8535
8536 #[test]
8537 fn runtime_attaches_registered_svg_images_to_render_output() {
8538 let (mut runtime, window_id, _, _) = build_runtime();
8539 let handle = ImageHandle::new(41);
8540 let svg = br##"<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 4 4"><rect width="4" height="4" fill="#27B7C8"/></svg>"##;
8541
8542 runtime
8543 .register_svg_image_at_size_with_handle(handle, 16, 16, svg)
8544 .unwrap();
8545
8546 let output = runtime.render(window_id).unwrap();
8547 let image = output.frame.image_registry.get(handle).unwrap();
8548
8549 assert_eq!(image.width(), 16);
8550 assert_eq!(image.height(), 16);
8551 assert!(image.bytes().chunks_exact(4).any(|pixel| pixel[3] > 0));
8552 }
8553
8554 #[test]
8555 fn semantics_only_invalidation_skips_repaint() {
8556 let (mut runtime, window_id, root_counters, leaf_counters) = build_runtime();
8557
8558 let _ = runtime.render(window_id).unwrap();
8559 let root_paint_before = root_counters.borrow().paint;
8560 let leaf_paint_before = leaf_counters.borrow().paint;
8561
8562 runtime
8563 .handle_event(window_id, Event::Custom(CustomEvent::new("semantics-only")))
8564 .unwrap();
8565
8566 assert_eq!(
8567 runtime.schedule(window_id).unwrap(),
8568 FrameSchedule {
8569 semantics: true,
8570 ..FrameSchedule::default()
8571 }
8572 );
8573
8574 let _ = runtime.render(window_id).unwrap();
8575
8576 assert_eq!(root_counters.borrow().paint, root_paint_before);
8577 assert_eq!(leaf_counters.borrow().paint, leaf_paint_before);
8578 assert!(root_counters.borrow().semantics >= 2);
8579 }
8580
8581 #[test]
8582 fn ordinary_widgets_flatten_scene_output_into_root() {
8583 let (mut runtime, window_id, _, _) = build_runtime();
8584
8585 let output = runtime.render(window_id).unwrap();
8586 let leaf_id = graph_child(&runtime.widget_graph(window_id).unwrap()).id;
8587
8588 assert!(!scene_has_layer_for(&output.frame.scene, leaf_id));
8589 }
8590
8591 #[test]
8592 fn explicit_paint_boundary_widgets_emit_layers() {
8593 let (mut runtime, window_id, _, _) = build_cached_move_runtime();
8594
8595 let output = runtime.render(window_id).unwrap();
8596 let layer_id = graph_child(&runtime.widget_graph(window_id).unwrap()).id;
8597
8598 assert!(scene_has_layer_for(&output.frame.scene, layer_id));
8599 }
8600
8601 #[test]
8602 fn flat_widgets_preserve_paint_bounds_larger_than_layout_bounds() {
8603 let (mut runtime, window_id) = build_overpaint_runtime();
8604
8605 let _ = runtime.render(window_id).unwrap();
8606 let graph = runtime.widget_graph(window_id).unwrap();
8607 let child = graph_child(&graph);
8608
8609 assert_eq!(child.bounds, Rect::new(32.0, 24.0, 120.0, 40.0));
8610 assert_eq!(child.geometry.paint_bounds, child.bounds.inflate(6.0, 4.0));
8611 }
8612
8613 #[test]
8614 fn paint_invalidation_repaints_nearest_boundary_root_for_flat_child() {
8615 let (mut runtime, window_id, root_counters, leaf_counters) = build_runtime();
8616
8617 let _ = runtime.render(window_id).unwrap();
8618 let leaf_id = graph_child(&runtime.widget_graph(window_id).unwrap()).id;
8619 let root_paint_before = root_counters.borrow().paint;
8620 let leaf_paint_before = leaf_counters.borrow().paint;
8621
8622 let mut pointer = PointerEvent::new(PointerEventKind::Down, Point::new(48.0, 40.0));
8623 pointer.button = Some(PointerButton::Primary);
8624 pointer.buttons = PointerButtons::new(1);
8625 runtime
8626 .handle_event(window_id, Event::Pointer(pointer))
8627 .unwrap();
8628
8629 let output = runtime.render(window_id).unwrap();
8630
8631 assert_eq!(root_counters.borrow().paint, root_paint_before + 1);
8632 assert_eq!(leaf_counters.borrow().paint, leaf_paint_before + 1);
8633 assert!(!scene_has_layer_for(&output.frame.scene, leaf_id));
8634 assert!(output.frame.layer_updates.is_empty());
8635 }
8636
8637 #[test]
8638 fn cached_layer_translation_updates_scene_without_repaint() {
8639 let (mut runtime, window_id, root_counters, leaf_counters) = build_cached_move_runtime();
8640
8641 let first = runtime.render(window_id).unwrap();
8642 let first_graph = runtime.widget_graph(window_id).unwrap();
8643 let initial_graph_bounds = graph_child(&first_graph).geometry.paint_bounds;
8644 let layer_id = graph_child(&first_graph).id;
8645 let root_paint_before = root_counters.borrow().paint;
8646 let leaf_paint_before = leaf_counters.borrow().paint;
8647 let initial_bounds = first
8648 .frame
8649 .scene
8650 .commands()
8651 .iter()
8652 .find_map(|command| match command {
8653 SceneCommand::Layer(layer) if layer.widget_id() == layer_id => Some(layer.bounds()),
8654 _ => None,
8655 })
8656 .expect("cached layer present before translation");
8657
8658 runtime
8659 .handle_event(window_id, Event::Custom(CustomEvent::new("shift-cached")))
8660 .unwrap();
8661
8662 let second = runtime.render(window_id).unwrap();
8663
8664 assert_eq!(root_counters.borrow().paint, root_paint_before);
8665 assert_eq!(leaf_counters.borrow().paint, leaf_paint_before);
8666 assert_eq!(second.frame.layer_updates.len(), 1);
8667 assert_eq!(second.frame.layer_updates[0].owner, layer_id);
8668 assert_eq!(
8669 second.frame.layer_updates[0].kind,
8670 SceneLayerUpdateKind::Transform
8671 );
8672
8673 let translated_bounds = second
8674 .frame
8675 .scene
8676 .commands()
8677 .iter()
8678 .find_map(|command| match command {
8679 SceneCommand::Layer(layer) if layer.widget_id() == layer_id => Some(layer.bounds()),
8680 _ => None,
8681 })
8682 .expect("cached layer present after translation");
8683
8684 assert_eq!(translated_bounds.x(), initial_bounds.x() + 48.0);
8685 assert_eq!(translated_bounds.y(), initial_bounds.y());
8686 let translated_graph_bounds = graph_child(&runtime.widget_graph(window_id).unwrap())
8687 .geometry
8688 .paint_bounds;
8689 assert_eq!(
8690 translated_graph_bounds,
8691 initial_graph_bounds.translate(Vector::new(48.0, 0.0))
8692 );
8693 }
8694
8695 #[test]
8696 fn composition_only_translation_keeps_ancestor_paint_bounds_conservative() {
8697 let root_counters = Rc::new(RefCell::new(Counters::default()));
8698 let leaf_counters = Rc::new(RefCell::new(Counters::default()));
8699 let presentation = Rc::new(RefCell::new(CachedLayerPresentation::default()));
8700 let mut runtime = Application::new()
8701 .window(
8702 WindowBuilder::new()
8703 .title("Bare cached move")
8704 .root(CachedMoveRoot {
8705 counters: Rc::clone(&root_counters),
8706 child: SingleChild::new(CachedMoveLeaf {
8707 counters: Rc::clone(&leaf_counters),
8708 presentation: Rc::clone(&presentation),
8709 }),
8710 presentation,
8711 offset_x: 0.0,
8712 paint_background: false,
8713 }),
8714 )
8715 .build()
8716 .unwrap();
8717 let window_id = runtime.window_ids()[0];
8718 let _ = runtime.render(window_id).unwrap();
8719 let initial_graph = runtime.widget_graph(window_id).unwrap();
8720 let initial_root_paint = initial_graph.nodes[0].geometry.paint_bounds;
8721 let initial_child_paint = graph_child(&initial_graph).geometry.paint_bounds;
8722 let root_paint_before = root_counters.borrow().paint;
8723 let leaf_paint_before = leaf_counters.borrow().paint;
8724
8725 runtime
8726 .handle_event(window_id, Event::Custom(CustomEvent::new("shift-cached")))
8727 .unwrap();
8728 let _ = runtime.render(window_id).unwrap();
8729 let shifted_graph = runtime.widget_graph(window_id).unwrap();
8730 let shifted_child_paint = graph_child(&shifted_graph).geometry.paint_bounds;
8731
8732 assert_eq!(root_counters.borrow().paint, root_paint_before);
8733 assert_eq!(leaf_counters.borrow().paint, leaf_paint_before);
8734 assert_eq!(
8735 shifted_graph.nodes[0].geometry.paint_bounds,
8736 initial_root_paint.union(shifted_child_paint)
8737 );
8738 assert_eq!(
8739 shifted_child_paint,
8740 initial_child_paint.translate(Vector::new(48.0, 0.0))
8741 );
8742 }
8743
8744 #[test]
8745 fn composition_only_translation_updates_focused_ime_rect() {
8746 let root_counters = Rc::new(RefCell::new(Counters::default()));
8747 let presentation = Rc::new(RefCell::new(CachedLayerPresentation::default()));
8748 let mut runtime = Application::new()
8749 .window(
8750 WindowBuilder::new()
8751 .title("Cached IME move")
8752 .root(CachedMoveRoot {
8753 counters: Rc::clone(&root_counters),
8754 child: SingleChild::new_with_paint_boundary(TextImeLeaf {
8755 layout: RefCell::new(None),
8756 }),
8757 presentation,
8758 offset_x: 0.0,
8759 paint_background: true,
8760 }),
8761 )
8762 .build()
8763 .unwrap();
8764 let window_id = runtime.window_ids()[0];
8765 let _ = runtime.render(window_id).unwrap();
8766
8767 let mut pointer = PointerEvent::new(PointerEventKind::Down, Point::new(40.0, 40.0));
8768 pointer.button = Some(PointerButton::Primary);
8769 pointer.buttons = PointerButtons::new(1);
8770 runtime
8771 .handle_event(window_id, Event::Pointer(pointer))
8772 .unwrap();
8773 let focused = runtime.render(window_id).unwrap();
8774 let initial_ime = focused
8775 .ime_composition_rect
8776 .expect("focused text layer should publish an IME rectangle");
8777 let initial_paint_bounds = graph_child(&runtime.widget_graph(window_id).unwrap())
8778 .geometry
8779 .paint_bounds;
8780 let root_paint_before = root_counters.borrow().paint;
8781
8782 runtime
8783 .handle_event(window_id, Event::Custom(CustomEvent::new("shift-cached")))
8784 .unwrap();
8785 let shifted = runtime.render(window_id).unwrap();
8786
8787 assert_eq!(root_counters.borrow().paint, root_paint_before);
8788 assert_eq!(
8789 shifted.ime_composition_rect,
8790 Some(initial_ime.translate(Vector::new(48.0, 0.0)))
8791 );
8792 assert_eq!(
8793 graph_child(&runtime.widget_graph(window_id).unwrap())
8794 .geometry
8795 .paint_bounds,
8796 initial_paint_bounds.translate(Vector::new(48.0, 0.0))
8797 );
8798 assert!(
8799 shifted
8800 .frame
8801 .layer_updates
8802 .iter()
8803 .any(|update| { update.kind == SceneLayerUpdateKind::Transform })
8804 );
8805 }
8806
8807 #[test]
8808 fn explicit_boundary_layer_property_translation_marks_transform_without_content_rebuild() {
8809 let (mut runtime, window_id, root_counters, leaf_counters) = build_cached_move_runtime();
8810
8811 let first = runtime.render(window_id).unwrap();
8812 let layer_id = graph_child(&runtime.widget_graph(window_id).unwrap()).id;
8813 let root_paint_before = root_counters.borrow().paint;
8814 let leaf_paint_before = leaf_counters.borrow().paint;
8815 let initial_layer = first
8816 .frame
8817 .scene
8818 .commands()
8819 .iter()
8820 .find_map(|command| match command {
8821 SceneCommand::Layer(layer) if layer.widget_id() == layer_id => Some(layer.clone()),
8822 _ => None,
8823 })
8824 .expect("cached layer present before property translation");
8825
8826 runtime
8827 .handle_event(
8828 window_id,
8829 Event::Custom(CustomEvent::new("nudge-cached-layer-property")),
8830 )
8831 .unwrap();
8832
8833 let second = runtime.render(window_id).unwrap();
8834 let updated_layer = second
8835 .frame
8836 .scene
8837 .commands()
8838 .iter()
8839 .find_map(|command| match command {
8840 SceneCommand::Layer(layer) if layer.widget_id() == layer_id => Some(layer.clone()),
8841 _ => None,
8842 })
8843 .expect("cached layer present after property translation");
8844
8845 assert_eq!(root_counters.borrow().paint, root_paint_before);
8846 assert_eq!(leaf_counters.borrow().paint, leaf_paint_before);
8847 assert_eq!(second.frame.layer_updates.len(), 1);
8848 assert_eq!(second.frame.layer_updates[0].owner, layer_id);
8849 assert_eq!(
8850 second.frame.layer_updates[0].kind,
8851 SceneLayerUpdateKind::Transform
8852 );
8853 assert_eq!(updated_layer.bounds(), initial_layer.bounds());
8854 assert_eq!(
8855 updated_layer.descriptor.properties.translation,
8856 Vector::new(18.0, 0.0)
8857 );
8858 assert_eq!(updated_layer.descriptor.properties.opacity, 1.0);
8859 }
8860
8861 #[test]
8862 fn explicit_boundary_layer_opacity_marks_effect_without_content_rebuild() {
8863 let (mut runtime, window_id, root_counters, leaf_counters) = build_cached_move_runtime();
8864
8865 let _ = runtime.render(window_id).unwrap();
8866 let layer_id = graph_child(&runtime.widget_graph(window_id).unwrap()).id;
8867 let root_paint_before = root_counters.borrow().paint;
8868 let leaf_paint_before = leaf_counters.borrow().paint;
8869
8870 runtime
8871 .handle_event(
8872 window_id,
8873 Event::Custom(CustomEvent::new("fade-cached-layer")),
8874 )
8875 .unwrap();
8876
8877 let second = runtime.render(window_id).unwrap();
8878 let updated_layer = second
8879 .frame
8880 .scene
8881 .commands()
8882 .iter()
8883 .find_map(|command| match command {
8884 SceneCommand::Layer(layer) if layer.widget_id() == layer_id => Some(layer.clone()),
8885 _ => None,
8886 })
8887 .expect("cached layer present after opacity update");
8888
8889 assert_eq!(root_counters.borrow().paint, root_paint_before);
8890 assert_eq!(leaf_counters.borrow().paint, leaf_paint_before);
8891 assert_eq!(second.frame.layer_updates.len(), 1);
8892 assert_eq!(second.frame.layer_updates[0].owner, layer_id);
8893 assert_eq!(
8894 second.frame.layer_updates[0].kind,
8895 SceneLayerUpdateKind::Effect
8896 );
8897 assert_eq!(
8898 updated_layer.descriptor.properties.translation,
8899 Vector::ZERO
8900 );
8901 assert_eq!(updated_layer.descriptor.properties.opacity, 0.5);
8902 }
8903
8904 #[test]
8905 fn direct_flat_child_translation_repaints_nearest_boundary_root() {
8906 let (mut runtime, window_id, root_counters, leaf_counters) = build_direct_move_runtime();
8907
8908 let first = runtime.render(window_id).unwrap();
8909 let layer_id = graph_child(&runtime.widget_graph(window_id).unwrap()).id;
8910 let root_paint_before = root_counters.borrow().paint;
8911 let leaf_paint_before = leaf_counters.borrow().paint;
8912 let initial_rect = first
8913 .frame
8914 .scene
8915 .commands()
8916 .iter()
8917 .find_map(|command| match command {
8918 SceneCommand::FillRect { rect, .. }
8919 if *rect != Rect::new(0.0, 0.0, 320.0, 180.0) =>
8920 {
8921 Some(*rect)
8922 }
8923 _ => None,
8924 })
8925 .expect("flat child fill present before translation");
8926
8927 runtime
8928 .handle_event(window_id, Event::Custom(CustomEvent::new("shift-direct")))
8929 .unwrap();
8930
8931 let second = runtime.render(window_id).unwrap();
8932
8933 assert_eq!(root_counters.borrow().paint, root_paint_before + 1);
8934 assert_eq!(leaf_counters.borrow().paint, leaf_paint_before + 1);
8935 assert!(!scene_has_layer_for(&second.frame.scene, layer_id));
8936 assert!(second.frame.layer_updates.is_empty());
8937
8938 let translated_rect = second
8939 .frame
8940 .scene
8941 .commands()
8942 .iter()
8943 .find_map(|command| match command {
8944 SceneCommand::FillRect { rect, .. }
8945 if *rect != Rect::new(0.0, 0.0, 320.0, 180.0) =>
8946 {
8947 Some(*rect)
8948 }
8949 _ => None,
8950 })
8951 .expect("flat child fill present after translation");
8952
8953 assert_eq!(translated_rect.x(), initial_rect.x() + 36.0);
8954 assert_eq!(translated_rect.y(), initial_rect.y());
8955 }
8956
8957 #[test]
8958 fn semantics_attach_to_the_nearest_ancestor_node() {
8959 let root_counters = Rc::new(RefCell::new(Counters::default()));
8960 let leaf_counters = Rc::new(RefCell::new(Counters::default()));
8961
8962 let mut runtime = Application::new()
8963 .window(WindowBuilder::new().title("Test").root(TestRoot {
8964 counters: Rc::clone(&root_counters),
8965 child: SingleChild::new(ChildRoot::new(FocusLeaf {
8966 counters: Rc::clone(&leaf_counters),
8967 })),
8968 }))
8969 .build()
8970 .unwrap();
8971
8972 let window_id = runtime.window_ids()[0];
8973 let output = runtime.render(window_id).unwrap();
8974 let root_id = output
8975 .semantics
8976 .iter()
8977 .find(|node| node.role == SemanticsRole::Window)
8978 .map(|node| node.id)
8979 .unwrap();
8980 let leaf = output
8981 .semantics
8982 .iter()
8983 .find(|node| node.role == SemanticsRole::Button)
8984 .unwrap();
8985
8986 assert_eq!(leaf.parent, Some(root_id));
8987 }
8988
8989 #[test]
8990 fn tab_traversal_moves_focus_between_focusable_widgets() {
8991 let (mut runtime, window_id, first_counters, second_counters) =
8992 build_focus_traversal_runtime();
8993
8994 let _ = runtime.render(window_id).unwrap();
8995 let graph = runtime.widget_graph(window_id).unwrap();
8996 let first_id = graph.nodes[1].id;
8997 let second_id = graph.nodes[2].id;
8998
8999 let mut pointer = PointerEvent::new(PointerEventKind::Down, Point::new(48.0, 40.0));
9000 pointer.button = Some(PointerButton::Primary);
9001 pointer.buttons = PointerButtons::new(1);
9002 runtime
9003 .handle_event(window_id, Event::Pointer(pointer))
9004 .unwrap();
9005
9006 assert_eq!(
9007 runtime.focus_state(window_id).unwrap(),
9008 FocusState {
9009 focused_widget: Some(first_id),
9010 window_focused: true,
9011 }
9012 );
9013 assert!(
9014 runtime
9015 .widget_graph(window_id)
9016 .unwrap()
9017 .nodes
9018 .iter()
9019 .find(|node| node.id == first_id)
9020 .is_some_and(|node| node.focused)
9021 );
9022
9023 runtime
9024 .handle_event(
9025 window_id,
9026 Event::Keyboard(KeyboardEvent::new("Tab", KeyState::Pressed)),
9027 )
9028 .unwrap();
9029
9030 assert_eq!(first_counters.borrow().keyboard, 1);
9031 assert_eq!(
9032 runtime.focus_state(window_id).unwrap(),
9033 FocusState {
9034 focused_widget: Some(second_id),
9035 window_focused: true,
9036 }
9037 );
9038 assert!(
9039 runtime
9040 .widget_graph(window_id)
9041 .unwrap()
9042 .nodes
9043 .iter()
9044 .find(|node| node.id == second_id)
9045 .is_some_and(|node| node.focused)
9046 );
9047
9048 let output = runtime.render(window_id).unwrap();
9049 assert!(
9050 output
9051 .semantics
9052 .iter()
9053 .find(|node| node.id == second_id)
9054 .is_some_and(|node| node.state.focused)
9055 );
9056
9057 let mut reverse_tab = KeyboardEvent::new("Tab", KeyState::Pressed);
9058 reverse_tab.modifiers.shift = true;
9059 runtime
9060 .handle_event(window_id, Event::Keyboard(reverse_tab))
9061 .unwrap();
9062
9063 assert_eq!(second_counters.borrow().keyboard, 1);
9064 assert_eq!(
9065 runtime.focus_state(window_id).unwrap(),
9066 FocusState {
9067 focused_widget: Some(first_id),
9068 window_focused: true,
9069 }
9070 );
9071 assert!(
9072 runtime
9073 .widget_graph(window_id)
9074 .unwrap()
9075 .nodes
9076 .iter()
9077 .find(|node| node.id == first_id)
9078 .is_some_and(|node| node.focused)
9079 );
9080 }
9081
9082 #[test]
9083 fn managed_overlay_traps_restores_and_traces_focus_and_dismissal() {
9084 let open = Rc::new(RefCell::new(false));
9085 let dismissals = Rc::new(RefCell::new(Vec::new()));
9086 let mut runtime = Application::new()
9087 .window(WindowBuilder::new().title("Managed overlay").root(
9088 ManagedOverlayTestRoot::new(Rc::clone(&open), Rc::clone(&dismissals)),
9089 ))
9090 .build()
9091 .unwrap();
9092 let window_id = runtime.window_ids()[0];
9093 let initial = runtime.render(window_id).unwrap();
9094 assert!(
9095 runtime
9096 .overlay_snapshot(window_id)
9097 .unwrap()
9098 .overlays
9099 .is_empty()
9100 );
9101
9102 let graph = runtime.widget_graph(window_id).unwrap();
9103 let root_id = graph.nodes[0].id;
9104 let background_id = graph
9105 .nodes
9106 .iter()
9107 .find(|node| node.parent == Some(root_id) && node.accepts_focus)
9108 .unwrap()
9109 .id;
9110 assert!(
9111 initial
9112 .semantics
9113 .iter()
9114 .any(|node| node.id == background_id)
9115 );
9116
9117 assert!(
9118 runtime
9119 .handle_semantics_action(window_id, background_id, SemanticsActionRequest::Focus,)
9120 .unwrap()
9121 );
9122 assert_eq!(
9123 runtime.focused_widget(window_id).unwrap(),
9124 Some(background_id)
9125 );
9126
9127 runtime
9128 .handle_event(
9129 window_id,
9130 Event::Custom(CustomEvent::new("open-managed-overlay")),
9131 )
9132 .unwrap();
9133 let opened = runtime.render(window_id).unwrap();
9134 let snapshot = runtime.overlay_snapshot(window_id).unwrap();
9135 assert_eq!(snapshot.overlays.len(), 1);
9136 assert_eq!(snapshot.active_modal, Some(snapshot.overlays[0].owner));
9137 assert_eq!(snapshot.focus_trap, Some(snapshot.overlays[0].owner));
9138 assert!(!opened.semantics.iter().any(|node| node.id == background_id));
9139 assert!(
9140 opened
9141 .semantics
9142 .iter()
9143 .any(|node| { node.id == snapshot.overlays[0].owner && node.state.modal })
9144 );
9145
9146 let first_overlay_focus = runtime.focused_widget(window_id).unwrap().unwrap();
9147 assert_ne!(first_overlay_focus, background_id);
9148 runtime
9149 .handle_event(
9150 window_id,
9151 Event::Keyboard(KeyboardEvent::new("Tab", KeyState::Pressed)),
9152 )
9153 .unwrap();
9154 let second_overlay_focus = runtime.focused_widget(window_id).unwrap().unwrap();
9155 assert_ne!(second_overlay_focus, first_overlay_focus);
9156 runtime
9157 .handle_event(
9158 window_id,
9159 Event::Keyboard(KeyboardEvent::new("Tab", KeyState::Pressed)),
9160 )
9161 .unwrap();
9162 assert_eq!(
9163 runtime.focused_widget(window_id).unwrap(),
9164 Some(first_overlay_focus)
9165 );
9166
9167 runtime
9168 .handle_event(
9169 window_id,
9170 Event::Keyboard(KeyboardEvent::new("Escape", KeyState::Pressed)),
9171 )
9172 .unwrap();
9173 assert_eq!(
9174 dismissals.borrow().as_slice(),
9175 &[OverlayDismissReason::Escape]
9176 );
9177 let _ = runtime.render(window_id).unwrap();
9178 assert!(
9179 runtime
9180 .overlay_snapshot(window_id)
9181 .unwrap()
9182 .overlays
9183 .is_empty()
9184 );
9185 assert_eq!(
9186 runtime.focused_widget(window_id).unwrap(),
9187 Some(background_id)
9188 );
9189
9190 let traces = runtime.take_overlay_traces(window_id).unwrap();
9191 for expected in [
9192 OverlayTraceKind::Opened,
9193 OverlayTraceKind::FocusEntered,
9194 OverlayTraceKind::DismissRequested,
9195 OverlayTraceKind::Closed,
9196 OverlayTraceKind::FocusRestored,
9197 ] {
9198 assert!(traces.iter().any(|trace| trace.kind == expected));
9199 }
9200 }
9201
9202 #[test]
9203 fn pointer_capture_routes_drag_events_until_pointer_up() {
9204 let (mut runtime, window_id, state) = build_pointer_capture_runtime();
9205
9206 let _ = runtime.render(window_id).unwrap();
9207 let child_id = graph_child(&runtime.widget_graph(window_id).unwrap()).id;
9208
9209 let mut down = PointerEvent::new(PointerEventKind::Down, Point::new(48.0, 40.0));
9210 down.pointer_id = 7;
9211 down.button = Some(PointerButton::Primary);
9212 down.buttons = PointerButtons::new(1);
9213 runtime
9214 .handle_event(window_id, Event::Pointer(down))
9215 .unwrap();
9216
9217 assert_eq!(
9218 runtime.pointer_capture_target(window_id, 7).unwrap(),
9219 Some(child_id)
9220 );
9221
9222 let mut moved = PointerEvent::new(PointerEventKind::Move, Point::new(260.0, 140.0));
9223 moved.pointer_id = 7;
9224 moved.buttons = PointerButtons::new(1);
9225 runtime
9226 .handle_event(window_id, Event::Pointer(moved))
9227 .unwrap();
9228
9229 let mut up = PointerEvent::new(PointerEventKind::Up, Point::new(260.0, 140.0));
9230 up.pointer_id = 7;
9231 up.button = Some(PointerButton::Primary);
9232 runtime.handle_event(window_id, Event::Pointer(up)).unwrap();
9233
9234 assert_eq!(state.borrow().moves, 1);
9235 assert_eq!(state.borrow().ups, 1);
9236 assert_eq!(state.borrow().cancels, 0);
9237 assert_eq!(runtime.pointer_capture_target(window_id, 7).unwrap(), None);
9238 }
9239
9240 #[test]
9241 fn window_focus_loss_cancels_all_pointer_captures_and_applies_cleanup_effects() {
9242 let (mut runtime, window_id, state) = build_pointer_capture_runtime();
9243
9244 let _ = runtime.render(window_id).unwrap();
9245 let child_id = graph_child(&runtime.widget_graph(window_id).unwrap()).id;
9246
9247 for pointer_id in [31, 47] {
9248 let mut down = PointerEvent::new(PointerEventKind::Down, Point::new(48.0, 40.0));
9249 down.pointer_id = pointer_id;
9250 down.pointer_kind = PointerKind::Touch;
9251 down.button = Some(PointerButton::Primary);
9252 down.buttons = PointerButtons::new(1);
9253 runtime
9254 .handle_event(window_id, Event::Pointer(down))
9255 .unwrap();
9256 assert_eq!(
9257 runtime
9258 .pointer_capture_target(window_id, pointer_id)
9259 .unwrap(),
9260 Some(child_id)
9261 );
9262 }
9263
9264 runtime
9265 .handle_event(window_id, Event::Window(WindowEvent::Focused(false)))
9266 .unwrap();
9267
9268 assert_eq!(state.borrow().cancels, 2);
9269 assert_eq!(state.borrow().cancel_followups, 2);
9270 assert!(runtime.needs_render(window_id).unwrap());
9271 for pointer_id in [31, 47] {
9272 assert_eq!(
9273 runtime
9274 .pointer_capture_target(window_id, pointer_id)
9275 .unwrap(),
9276 None
9277 );
9278 }
9279 }
9280
9281 #[test]
9282 fn pointer_capture_transfer_cancels_displaced_owner_and_preserves_new_owner() {
9283 let state = Rc::new(RefCell::new(PointerCaptureState::default()));
9284 let mut runtime = Application::new()
9285 .window(WindowBuilder::new().title("Pointer Capture Transfer").root(
9286 PointerCaptureTransferRoot::new(PointerCaptureLeaf {
9287 state: Rc::clone(&state),
9288 recapture_on_move: false,
9289 }),
9290 ))
9291 .build()
9292 .unwrap();
9293 let window_id = runtime.window_ids()[0];
9294
9295 let _ = runtime.render(window_id).unwrap();
9296 let graph = runtime.widget_graph(window_id).unwrap();
9297 let root_id = graph.root;
9298 let child_id = graph_child(&graph).id;
9299
9300 let mut down = PointerEvent::new(PointerEventKind::Down, Point::new(48.0, 40.0));
9301 down.pointer_id = 17;
9302 down.pointer_kind = PointerKind::Touch;
9303 down.button = Some(PointerButton::Primary);
9304 down.buttons = PointerButtons::new(1);
9305 runtime
9306 .handle_event(window_id, Event::Pointer(down))
9307 .unwrap();
9308 assert_eq!(
9309 runtime.pointer_capture_target(window_id, 17).unwrap(),
9310 Some(child_id)
9311 );
9312
9313 let mut moved = PointerEvent::new(PointerEventKind::Move, Point::new(48.0, 18.0));
9314 moved.pointer_id = 17;
9315 moved.pointer_kind = PointerKind::Touch;
9316 moved.delta = Vector::new(0.0, -22.0);
9317 moved.buttons = PointerButtons::new(1);
9318 runtime
9319 .handle_event(window_id, Event::Pointer(moved))
9320 .unwrap();
9321
9322 assert_eq!(
9323 runtime.pointer_capture_target(window_id, 17).unwrap(),
9324 Some(root_id),
9325 "the displaced owner's release request must not clear the new capture"
9326 );
9327 assert!(
9328 runtime.needs_render(window_id).unwrap(),
9329 "the displaced owner's invalidations must be applied"
9330 );
9331 let state = state.borrow();
9332 assert_eq!(state.cancels, 1);
9333 assert_eq!(state.cancel_followups, 1);
9334 let cancel = state.last_cancel.as_ref().expect("cancel event recorded");
9335 assert_eq!(cancel.pointer_id, 17);
9336 assert_eq!(cancel.kind, PointerEventKind::Cancel);
9337 assert_eq!(cancel.position, Point::new(48.0, 18.0));
9338 assert_eq!(cancel.delta, Vector::ZERO);
9339 assert_eq!(cancel.pointer_kind, PointerKind::Touch);
9340 assert_eq!(cancel.button, None);
9341 assert_eq!(cancel.buttons, PointerButtons::NONE);
9342 assert_eq!(cancel.scroll_delta, None);
9343 }
9344
9345 #[test]
9346 fn pointer_capture_transfer_cancels_reentrant_intermediate_owner() {
9347 let state = Rc::new(RefCell::new(ReentrantCaptureState::default()));
9348 let mut runtime = Application::new()
9349 .window(
9350 WindowBuilder::new()
9351 .title("Reentrant Pointer Capture Transfer")
9352 .root(ReentrantCaptureRoot::new(Rc::clone(&state))),
9353 )
9354 .build()
9355 .unwrap();
9356 let window_id = runtime.window_ids()[0];
9357
9358 let _ = runtime.render(window_id).unwrap();
9359 let graph = runtime.widget_graph(window_id).unwrap();
9360 let root_id = graph.root;
9361 let source_id = graph.nodes[1].id;
9362
9363 let mut down = PointerEvent::new(PointerEventKind::Down, Point::new(48.0, 40.0));
9364 down.pointer_id = 59;
9365 down.pointer_kind = PointerKind::Touch;
9366 down.button = Some(PointerButton::Primary);
9367 down.buttons = PointerButtons::new(1);
9368 runtime
9369 .handle_event(window_id, Event::Pointer(down))
9370 .unwrap();
9371 assert_eq!(
9372 runtime.pointer_capture_target(window_id, 59).unwrap(),
9373 Some(source_id)
9374 );
9375
9376 let mut moved = PointerEvent::new(PointerEventKind::Move, Point::new(48.0, 18.0));
9377 moved.pointer_id = 59;
9378 moved.pointer_kind = PointerKind::Touch;
9379 moved.delta = Vector::new(0.0, -22.0);
9380 moved.buttons = PointerButtons::new(1);
9381 runtime
9382 .handle_event(window_id, Event::Pointer(moved))
9383 .unwrap();
9384
9385 let state = state.borrow();
9386 assert_eq!(state.source_cancels, 1);
9387 assert_eq!(state.intermediate_captures, 1);
9388 assert_eq!(state.intermediate_cancels, 1);
9389 assert_eq!(
9390 runtime.pointer_capture_target(window_id, 59).unwrap(),
9391 Some(root_id),
9392 "the original transfer target must win after intermediate cleanup"
9393 );
9394 }
9395
9396 #[test]
9397 fn recapturing_pointer_for_same_owner_does_not_emit_cancel() {
9398 let state = Rc::new(RefCell::new(PointerCaptureState::default()));
9399 let mut runtime = Application::new()
9400 .window(
9401 WindowBuilder::new()
9402 .title("Pointer Recapture")
9403 .root(ChildRoot::new(PointerCaptureLeaf {
9404 state: Rc::clone(&state),
9405 recapture_on_move: true,
9406 })),
9407 )
9408 .build()
9409 .unwrap();
9410 let window_id = runtime.window_ids()[0];
9411
9412 let _ = runtime.render(window_id).unwrap();
9413 let child_id = graph_child(&runtime.widget_graph(window_id).unwrap()).id;
9414
9415 let mut down = PointerEvent::new(PointerEventKind::Down, Point::new(48.0, 40.0));
9416 down.pointer_id = 23;
9417 down.button = Some(PointerButton::Primary);
9418 down.buttons = PointerButtons::new(1);
9419 runtime
9420 .handle_event(window_id, Event::Pointer(down))
9421 .unwrap();
9422
9423 let mut moved = PointerEvent::new(PointerEventKind::Move, Point::new(80.0, 40.0));
9424 moved.pointer_id = 23;
9425 moved.delta = Vector::new(32.0, 0.0);
9426 moved.buttons = PointerButtons::new(1);
9427 runtime
9428 .handle_event(window_id, Event::Pointer(moved))
9429 .unwrap();
9430
9431 assert_eq!(state.borrow().cancels, 0);
9432 assert_eq!(
9433 runtime.pointer_capture_target(window_id, 23).unwrap(),
9434 Some(child_id)
9435 );
9436 }
9437
9438 #[test]
9439 fn active_drag_hit_tests_drop_target_while_source_keeps_pointer_capture() {
9440 let state = Rc::new(RefCell::new(RuntimeDragState::default()));
9441 let mut runtime = Application::new()
9442 .window(
9443 WindowBuilder::new()
9444 .title("Runtime Drag")
9445 .root(RuntimeDragRoot::new(Rc::clone(&state))),
9446 )
9447 .build()
9448 .unwrap();
9449 let window_id = runtime.window_ids()[0];
9450
9451 let _ = runtime.render(window_id).unwrap();
9452
9453 let mut down = PointerEvent::new(PointerEventKind::Down, Point::new(48.0, 40.0));
9454 down.pointer_id = 7;
9455 down.button = Some(PointerButton::Primary);
9456 down.buttons = PointerButtons::new(1);
9457 runtime
9458 .handle_event(window_id, Event::Pointer(down))
9459 .unwrap();
9460
9461 let mut moved = PointerEvent::new(PointerEventKind::Move, Point::new(188.0, 40.0));
9462 moved.pointer_id = 7;
9463 moved.buttons = PointerButtons::new(1);
9464 runtime
9465 .handle_event(window_id, Event::Pointer(moved))
9466 .unwrap();
9467
9468 let mut up = PointerEvent::new(PointerEventKind::Up, Point::new(188.0, 40.0));
9469 up.pointer_id = 7;
9470 up.button = Some(PointerButton::Primary);
9471 runtime.handle_event(window_id, Event::Pointer(up)).unwrap();
9472
9473 let state = state.borrow();
9474 assert_eq!(state.source_moves, 1);
9475 assert!(state.target_overs >= 1);
9476 assert_eq!(state.drops, 1);
9477 assert_eq!(state.ends, 1);
9478 assert!(matches!(
9479 state.outcome,
9480 Some(DragOutcome::Dropped {
9481 effect: DropEffect::Move,
9482 ..
9483 })
9484 ));
9485 }
9486
9487 #[test]
9488 fn pointer_move_synthesizes_widget_leave_and_enter_transitions() {
9489 let (mut runtime, window_id, first, second) = build_hover_transition_runtime();
9490
9491 let _ = runtime.render(window_id).unwrap();
9492
9493 runtime
9494 .handle_event(
9495 window_id,
9496 Event::Pointer(PointerEvent::new(
9497 PointerEventKind::Move,
9498 Point::new(48.0, 40.0),
9499 )),
9500 )
9501 .unwrap();
9502
9503 assert_eq!(
9504 *first.borrow(),
9505 HoverTransitionState {
9506 enters: 1,
9507 leaves: 0,
9508 hovered: true,
9509 }
9510 );
9511 assert_eq!(*second.borrow(), HoverTransitionState::default());
9512
9513 runtime
9514 .handle_event(
9515 window_id,
9516 Event::Pointer(PointerEvent::new(
9517 PointerEventKind::Move,
9518 Point::new(280.0, 140.0),
9519 )),
9520 )
9521 .unwrap();
9522
9523 assert_eq!(
9524 *first.borrow(),
9525 HoverTransitionState {
9526 enters: 1,
9527 leaves: 1,
9528 hovered: false,
9529 }
9530 );
9531
9532 runtime
9533 .handle_event(
9534 window_id,
9535 Event::Pointer(PointerEvent::new(
9536 PointerEventKind::Move,
9537 Point::new(188.0, 40.0),
9538 )),
9539 )
9540 .unwrap();
9541
9542 assert_eq!(
9543 *second.borrow(),
9544 HoverTransitionState {
9545 enters: 1,
9546 leaves: 0,
9547 hovered: true,
9548 }
9549 );
9550 }
9551
9552 #[test]
9553 fn timers_and_async_wakeups_reenter_runtime_with_registered_target() {
9554 let (mut runtime, window_id, state) = build_wake_runtime();
9555
9556 let _ = runtime.render(window_id).unwrap();
9557
9558 let mut down = PointerEvent::new(PointerEventKind::Down, Point::new(48.0, 40.0));
9559 down.pointer_id = 11;
9560 down.button = Some(PointerButton::Primary);
9561 down.buttons = PointerButtons::new(1);
9562 runtime
9563 .handle_event(window_id, Event::Pointer(down))
9564 .unwrap();
9565
9566 let async_token = state.borrow().async_token.unwrap();
9567 let timer_token = state.borrow().timer_token.unwrap();
9568
9569 let scheduler = runtime.inspector_snapshot(window_id).unwrap().scheduler;
9570 assert!(scheduler.timers.iter().any(|timer| {
9571 timer.token == timer_token && timer.deadline == 3.0 && !timer.delivering
9572 }));
9573 assert!(
9574 scheduler
9575 .async_tasks
9576 .iter()
9577 .any(|task| { task.token == async_token && !task.pending_wake })
9578 );
9579
9580 assert_eq!(runtime.next_wakeup_time(window_id).unwrap(), Some(3.0));
9581 assert!(runtime.wake_async(window_id, async_token).unwrap());
9582
9583 let ready = runtime.drain_ready_events();
9584 assert_eq!(ready.len(), 1);
9585 assert!(matches!(
9586 ready[0],
9587 (ready_window, Event::Wake(WakeEvent::Async { token, time }))
9588 if ready_window == window_id && token == async_token && time == 0.0
9589 ));
9590
9591 for (ready_window, event) in ready {
9592 runtime.handle_event(ready_window, event).unwrap();
9593 }
9594
9595 assert_eq!(state.borrow().async_wakes, 1);
9596
9597 runtime.tick(3.0);
9598 let ready = runtime.drain_ready_events();
9599 assert_eq!(ready.len(), 1);
9600 assert!(matches!(
9601 ready[0],
9602 (ready_window, Event::Wake(WakeEvent::Timer { token, time, deadline }))
9603 if ready_window == window_id && token == timer_token && time == 3.0 && deadline == 3.0
9604 ));
9605
9606 for (ready_window, event) in ready {
9607 runtime.handle_event(ready_window, event).unwrap();
9608 }
9609
9610 assert_eq!(state.borrow().timer_wakes, 1);
9611 assert_eq!(runtime.next_wakeup_time(window_id).unwrap(), None);
9612 }
9613
9614 #[test]
9615 fn animation_frame_wakeups_reenter_runtime_with_registered_target() {
9616 let (mut runtime, window_id, state) = build_animation_wake_runtime(false);
9617
9618 let _ = runtime.render(window_id).unwrap();
9619
9620 let mut down = PointerEvent::new(PointerEventKind::Down, Point::new(48.0, 40.0));
9621 down.pointer_id = 12;
9622 down.button = Some(PointerButton::Primary);
9623 down.buttons = PointerButtons::new(1);
9624 runtime
9625 .handle_event(window_id, Event::Pointer(down))
9626 .unwrap();
9627
9628 assert_eq!(runtime.next_wakeup_time(window_id).unwrap(), Some(0.0));
9629
9630 let ready = runtime.drain_ready_events();
9631 assert_eq!(ready.len(), 1);
9632 assert!(matches!(
9633 ready[0],
9634 (
9635 ready_window,
9636 Event::Wake(WakeEvent::AnimationFrame {
9637 time,
9638 delta,
9639 frame_index,
9640 })
9641 ) if ready_window == window_id && time == 0.0 && delta == 0.0 && frame_index == 0
9642 ));
9643
9644 for (ready_window, event) in ready {
9645 runtime.handle_event(ready_window, event).unwrap();
9646 }
9647
9648 let state = state.borrow();
9649 assert_eq!(state.animation_wakes, 1);
9650 assert_eq!(state.last_animation_time, Some(0.0));
9651 assert_eq!(state.last_animation_delta, Some(0.0));
9652 assert_eq!(state.last_animation_frame_index, Some(0));
9653 assert_eq!(runtime.next_wakeup_time(window_id).unwrap(), None);
9654 }
9655
9656 #[test]
9657 fn animation_frame_wakeups_are_target_only_not_captured_by_ancestors() {
9658 let state = Rc::new(RefCell::new(AnimationWakeState::default()));
9659 let ancestor_wakes = Rc::new(RefCell::new(0usize));
9660 let mut runtime = Application::new()
9661 .window(WindowBuilder::new().title("Animation Capture").root(
9662 AnimationWakeCapturingRoot {
9663 child: SingleChild::new(AnimationWakeLeaf {
9664 state: Rc::clone(&state),
9665 }),
9666 ancestor_wakes: Rc::clone(&ancestor_wakes),
9667 },
9668 ))
9669 .build()
9670 .unwrap();
9671 let window_id = runtime.window_ids()[0];
9672
9673 let _ = runtime.render(window_id).unwrap();
9674
9675 let mut down = PointerEvent::new(PointerEventKind::Down, Point::new(48.0, 40.0));
9676 down.pointer_id = 15;
9677 down.button = Some(PointerButton::Primary);
9678 down.buttons = PointerButtons::new(1);
9679 runtime
9680 .handle_event(window_id, Event::Pointer(down))
9681 .unwrap();
9682
9683 let ready = runtime.drain_ready_events();
9684 assert_eq!(ready.len(), 1);
9685 for (ready_window, event) in ready {
9686 runtime.handle_event(ready_window, event).unwrap();
9687 }
9688
9689 assert_eq!(state.borrow().animation_wakes, 1);
9690 assert_eq!(*ancestor_wakes.borrow(), 0);
9691 assert_eq!(runtime.next_wakeup_time(window_id).unwrap(), None);
9692 }
9693
9694 #[test]
9695 fn repeated_animation_frame_requests_are_idempotent_for_the_same_widget() {
9696 let (mut runtime, window_id, state) = build_animation_wake_runtime(true);
9697
9698 let _ = runtime.render(window_id).unwrap();
9699
9700 let mut down = PointerEvent::new(PointerEventKind::Down, Point::new(48.0, 40.0));
9701 down.pointer_id = 13;
9702 down.button = Some(PointerButton::Primary);
9703 down.buttons = PointerButtons::new(1);
9704 runtime
9705 .handle_event(window_id, Event::Pointer(down))
9706 .unwrap();
9707
9708 let ready = runtime.drain_ready_events();
9709 assert_eq!(ready.len(), 1);
9710
9711 for (ready_window, event) in ready {
9712 runtime.handle_event(ready_window, event).unwrap();
9713 }
9714
9715 assert_eq!(state.borrow().animation_wakes, 1);
9716 assert_eq!(runtime.next_wakeup_time(window_id).unwrap(), None);
9717 }
9718
9719 #[test]
9720 fn animated_widget_registration_is_cleaned_up_when_widget_disappears() {
9721 let (mut runtime, window_id) = build_removable_animation_runtime();
9722
9723 let _ = runtime.render(window_id).unwrap();
9724
9725 let mut down = PointerEvent::new(PointerEventKind::Down, Point::new(48.0, 40.0));
9726 down.pointer_id = 14;
9727 down.button = Some(PointerButton::Primary);
9728 down.buttons = PointerButtons::new(1);
9729 runtime
9730 .handle_event(window_id, Event::Pointer(down))
9731 .unwrap();
9732
9733 assert_eq!(runtime.next_wakeup_time(window_id).unwrap(), Some(0.0));
9734
9735 runtime
9736 .handle_event(
9737 window_id,
9738 Event::Custom(CustomEvent::new("drop-animation-child")),
9739 )
9740 .unwrap();
9741 let _ = runtime.render(window_id).unwrap();
9742
9743 assert_eq!(runtime.next_wakeup_time(window_id).unwrap(), None);
9744 assert!(runtime.drain_ready_events().is_empty());
9745 }
9746
9747 #[test]
9748 fn initial_runtime_needs_render() {
9749 let (runtime, window_id, _, _) = build_runtime();
9750
9751 assert!(runtime.needs_render(window_id).unwrap());
9752 }
9753
9754 #[test]
9755 fn runtime_render_populates_widget_count_diagnostics() {
9756 let (mut runtime, window_id, _, _) = build_runtime();
9757
9758 let output = runtime.render(window_id).unwrap();
9759 let graph = runtime.widget_graph(window_id).unwrap();
9760
9761 assert_eq!(output.diagnostics.widget_count, graph.nodes.len());
9762 }
9763
9764 #[test]
9765 fn inspector_snapshot_unifies_structure_routes_and_widget_diagnostics() {
9766 let (mut runtime, window_id, _, _) = build_runtime();
9767 runtime.set_inspector_tracing(window_id, true).unwrap();
9768 runtime.render(window_id).unwrap();
9769
9770 runtime
9771 .handle_event(
9772 window_id,
9773 Event::Pointer(PointerEvent::new(
9774 PointerEventKind::Down,
9775 Point::new(48.0, 40.0),
9776 )),
9777 )
9778 .unwrap();
9779
9780 let snapshot = runtime.inspector_snapshot(window_id).unwrap();
9781 assert_eq!(snapshot.title, "Test");
9782 assert!(!snapshot.semantics.is_empty());
9783 assert!(
9784 snapshot
9785 .widget_graph
9786 .nodes
9787 .iter()
9788 .any(|node| node.widget_name.ends_with("TestRoot"))
9789 );
9790 assert!(snapshot.widget_diagnostics.iter().any(|diagnostics| {
9791 diagnostics.widget_name.ends_with("TestRoot")
9792 && diagnostics
9793 .entries
9794 .iter()
9795 .any(|entry| entry.name == "test state" && entry.value == "available")
9796 }));
9797 let route = snapshot.history.event_routes.last().unwrap();
9798 assert_eq!(route.event_kind, "pointer");
9799 assert!(route.steps.iter().any(|step| {
9800 step.phase == EventRoutePhase::Capture || step.phase == EventRoutePhase::Target
9801 }));
9802 assert!(snapshot.scene.is_some());
9803 }
9804
9805 struct ReactiveTextLeaf {
9806 text: Signal<String>,
9807 measures: Arc<AtomicUsize>,
9808 }
9809
9810 impl Widget for ReactiveTextLeaf {
9811 fn measure(&mut self, ctx: &mut MeasureCtx, constraints: Constraints) -> Size {
9812 let text = ctx.observe_with(&self.text, InvalidationKind::Text);
9813 self.measures.fetch_add(1, Ordering::Relaxed);
9814 constraints.clamp(Size::new(text.len() as f32 * 8.0, 24.0))
9815 }
9816
9817 fn semantics(&self, ctx: &mut SemanticsCtx) {
9818 let mut node = SemanticsNode::new(ctx.widget_id(), SemanticsRole::Text, ctx.bounds());
9819 node.name = Some(self.text.get());
9820 ctx.push(node);
9821 }
9822 }
9823
9824 #[test]
9825 fn observable_change_targets_widget_and_reports_diagnostics() {
9826 let text = Signal::named("status_text", "Ready".to_string());
9827 let measures = Arc::new(AtomicUsize::new(0));
9828 let mut runtime = Application::new()
9829 .window(WindowBuilder::new().root(ReactiveTextLeaf {
9830 text: text.clone(),
9831 measures: Arc::clone(&measures),
9832 }))
9833 .build()
9834 .unwrap();
9835 let window_id = runtime.window_ids()[0];
9836 let wakes = Arc::new(AtomicUsize::new(0));
9837 let wake_count = Arc::clone(&wakes);
9838 runtime.set_external_waker(move || {
9839 wake_count.fetch_add(1, Ordering::Relaxed);
9840 });
9841
9842 let first = runtime.render(window_id).unwrap();
9843 assert_eq!(measures.load(Ordering::Relaxed), 1);
9844 assert_eq!(first.semantics[0].name.as_deref(), Some("Ready"));
9845
9846 assert!(text.set("Connecting".to_string()));
9847 assert!(text.set("Connected".to_string()));
9848 assert_eq!(wakes.load(Ordering::Relaxed), 1);
9849 assert!(runtime.needs_render(window_id).unwrap());
9850
9851 let second = runtime.render(window_id).unwrap();
9852 assert_eq!(measures.load(Ordering::Relaxed), 2);
9853 assert_eq!(second.semantics[0].name.as_deref(), Some("Connected"));
9854 let samples = second
9855 .diagnostics
9856 .reactive_invalidations
9857 .iter()
9858 .filter(|sample| {
9859 sample.source_name == "status_text"
9860 && sample.kind == InvalidationKind::Text
9861 && sample.delivered
9862 })
9863 .collect::<Vec<_>>();
9864 assert_eq!(samples.len(), 1);
9865 assert_eq!(samples[0].version, 2);
9866 }
9867
9868 static TEST_COMMAND: CommandKey<u32> = CommandKey::new("runtime.test.command");
9869
9870 struct CommandRoot {
9871 commands: Arc<AtomicUsize>,
9872 custom_events: Arc<AtomicUsize>,
9873 }
9874
9875 impl Widget for CommandRoot {
9876 fn event(&mut self, _ctx: &mut EventCtx, event: &Event) {
9877 if matches!(event, Event::Custom(_)) {
9878 self.custom_events.fetch_add(1, Ordering::Relaxed);
9879 }
9880 }
9881
9882 fn command(&mut self, ctx: &mut EventCtx, command: &Command<'_>) {
9883 if command.get(TEST_COMMAND).is_some() {
9884 self.commands.fetch_add(1, Ordering::Relaxed);
9885 ctx.request_paint();
9886 ctx.set_handled();
9887 }
9888 }
9889
9890 fn measure(&mut self, _ctx: &mut MeasureCtx, constraints: Constraints) -> Size {
9891 constraints.clamp(Size::new(120.0, 80.0))
9892 }
9893 }
9894
9895 struct WakeController(Arc<AtomicUsize>);
9896
9897 impl CommandController for WakeController {
9898 fn wake(&mut self, _ctx: &mut CommandCtx) {
9899 self.0.fetch_add(1, Ordering::Relaxed);
9900 }
9901 }
9902
9903 struct EventCommandRoot;
9904
9905 impl Widget for EventCommandRoot {
9906 fn event(&mut self, ctx: &mut EventCtx, event: &Event) {
9907 if matches!(event, Event::Custom(_)) {
9908 ctx.command_sender().send_application(TEST_COMMAND, 41);
9909 }
9910 }
9911
9912 fn measure(&mut self, _ctx: &mut MeasureCtx, constraints: Constraints) -> Size {
9913 constraints.clamp(Size::new(120.0, 80.0))
9914 }
9915 }
9916
9917 #[test]
9918 fn scheduler_wake_invokes_controllers_without_synthesizing_a_root_event() {
9919 let controller_wakes = Arc::new(AtomicUsize::new(0));
9920 let custom_events = Arc::new(AtomicUsize::new(0));
9921 let mut runtime = Application::new()
9922 .window(
9923 WindowBuilder::new()
9924 .controller(WakeController(Arc::clone(&controller_wakes)))
9925 .root(CommandRoot {
9926 commands: Arc::new(AtomicUsize::new(0)),
9927 custom_events: Arc::clone(&custom_events),
9928 }),
9929 )
9930 .build()
9931 .unwrap();
9932
9933 runtime.command_sender().wake();
9934 runtime.process_commands();
9935
9936 assert_eq!(controller_wakes.load(Ordering::Relaxed), 1);
9937 assert_eq!(custom_events.load(Ordering::Relaxed), 0);
9938 }
9939
9940 #[test]
9941 fn widget_event_context_can_enqueue_an_application_command() {
9942 let received = Arc::new(AtomicUsize::new(0));
9943 let received_by_handler = Arc::clone(&received);
9944 let mut runtime = Application::new()
9945 .on_command(TEST_COMMAND, move |ctx, value| {
9946 received_by_handler.store(*value as usize, Ordering::Relaxed);
9947 ctx.set_handled();
9948 })
9949 .window(WindowBuilder::new().root(EventCommandRoot))
9950 .build()
9951 .unwrap();
9952 let window_id = runtime.window_ids()[0];
9953
9954 runtime
9955 .handle_event(
9956 window_id,
9957 Event::Custom(CustomEvent::new("runtime.test.enqueue-command")),
9958 )
9959 .unwrap();
9960 assert_eq!(received.load(Ordering::Relaxed), 0);
9961
9962 runtime.process_commands();
9963 assert_eq!(received.load(Ordering::Relaxed), 41);
9964 }
9965
9966 #[test]
9967 fn directed_commands_stop_when_handled_while_broadcast_reaches_all_subscribers() {
9968 let first = Arc::new(AtomicUsize::new(0));
9969 let second = Arc::new(AtomicUsize::new(0));
9970 let first_handler = Arc::clone(&first);
9971 let second_handler = Arc::clone(&second);
9972 let mut runtime = Application::new()
9973 .window(
9974 WindowBuilder::new()
9975 .on_command(TEST_COMMAND, move |ctx, _| {
9976 first_handler.fetch_add(1, Ordering::Relaxed);
9977 ctx.set_handled();
9978 })
9979 .on_command(TEST_COMMAND, move |_, _| {
9980 second_handler.fetch_add(1, Ordering::Relaxed);
9981 })
9982 .root(CommandRoot {
9983 commands: Arc::new(AtomicUsize::new(0)),
9984 custom_events: Arc::new(AtomicUsize::new(0)),
9985 }),
9986 )
9987 .build()
9988 .unwrap();
9989 let window_id = runtime.window_ids()[0];
9990 let sender = runtime.command_sender();
9991
9992 sender.send_window(window_id, TEST_COMMAND, 1);
9993 runtime.process_commands();
9994 assert_eq!(first.load(Ordering::Relaxed), 1);
9995 assert_eq!(second.load(Ordering::Relaxed), 0);
9996
9997 sender.broadcast_window(window_id, TEST_COMMAND, 2);
9998 runtime.process_commands();
9999 assert_eq!(first.load(Ordering::Relaxed), 2);
10000 assert_eq!(second.load(Ordering::Relaxed), 1);
10001 }
10002
10003 #[test]
10004 fn application_broadcast_is_thread_safe_multicast_and_drops_removed_window_subscriptions() {
10005 let application_count = Arc::new(AtomicUsize::new(0));
10006 let first_window_count = Arc::new(AtomicUsize::new(0));
10007 let second_window_count = Arc::new(AtomicUsize::new(0));
10008 let application_handler = Arc::clone(&application_count);
10009 let first_handler = Arc::clone(&first_window_count);
10010 let second_handler = Arc::clone(&second_window_count);
10011 let root = || CommandRoot {
10012 commands: Arc::new(AtomicUsize::new(0)),
10013 custom_events: Arc::new(AtomicUsize::new(0)),
10014 };
10015 let mut runtime = Application::new()
10016 .on_command(TEST_COMMAND, move |_, _| {
10017 application_handler.fetch_add(1, Ordering::Relaxed);
10018 })
10019 .window(
10020 WindowBuilder::new()
10021 .on_command(TEST_COMMAND, move |_, _| {
10022 first_handler.fetch_add(1, Ordering::Relaxed);
10023 })
10024 .root(root()),
10025 )
10026 .window(
10027 WindowBuilder::new()
10028 .on_command(TEST_COMMAND, move |_, _| {
10029 second_handler.fetch_add(1, Ordering::Relaxed);
10030 })
10031 .root(root()),
10032 )
10033 .build()
10034 .unwrap();
10035 let first_window = runtime.window_ids()[0];
10036 let sender = runtime.command_sender();
10037 let producer = std::thread::spawn(move || {
10038 sender.broadcast_application(TEST_COMMAND, 1);
10039 sender
10040 });
10041 let sender = producer.join().unwrap();
10042
10043 runtime.process_commands();
10044 assert_eq!(application_count.load(Ordering::Relaxed), 1);
10045 assert_eq!(first_window_count.load(Ordering::Relaxed), 1);
10046 assert_eq!(second_window_count.load(Ordering::Relaxed), 1);
10047
10048 runtime.remove_window(first_window).unwrap();
10049 sender.broadcast_application(TEST_COMMAND, 2);
10050 runtime.process_commands();
10051 assert_eq!(application_count.load(Ordering::Relaxed), 2);
10052 assert_eq!(first_window_count.load(Ordering::Relaxed), 1);
10053 assert_eq!(second_window_count.load(Ordering::Relaxed), 2);
10054 }
10055
10056 #[test]
10057 fn widget_commands_and_controller_invalidations_are_traced() {
10058 let commands = Arc::new(AtomicUsize::new(0));
10059 let mut runtime = Application::new()
10060 .window(
10061 WindowBuilder::new()
10062 .on_command(TEST_COMMAND, |ctx, _| {
10063 ctx.request_window_with_reason(
10064 InvalidationKind::Paint,
10065 "test command changed presentation",
10066 );
10067 })
10068 .root(CommandRoot {
10069 commands: Arc::clone(&commands),
10070 custom_events: Arc::new(AtomicUsize::new(0)),
10071 }),
10072 )
10073 .build()
10074 .unwrap();
10075 let window_id = runtime.window_ids()[0];
10076 runtime.render(window_id).unwrap();
10077 let root_id = runtime.widget_graph(window_id).unwrap().root;
10078 let sender = runtime.command_sender();
10079
10080 sender.send_widget(window_id, root_id, TEST_COMMAND, 1);
10081 sender.send_widget(window_id, WidgetId::new(u64::MAX), TEST_COMMAND, 2);
10082 sender.send_window(window_id, TEST_COMMAND, 3);
10083 runtime.process_commands();
10084 let output = runtime.render(window_id).unwrap();
10085
10086 assert_eq!(commands.load(Ordering::Relaxed), 1);
10087 assert!(output.diagnostics.command_dispatches.iter().any(|sample| {
10088 sample.name == TEST_COMMAND.name()
10089 && sample.payload_type == std::any::type_name::<u32>()
10090 && sample.delivered
10091 }));
10092 assert!(output.diagnostics.command_dispatches.iter().any(|sample| {
10093 sample.name == TEST_COMMAND.name()
10094 && matches!(sample.target, CommandTarget::Widget { widget_id, .. } if widget_id == WidgetId::new(u64::MAX))
10095 && !sample.delivered
10096 }));
10097 assert!(output.diagnostics.invalidations.iter().any(|sample| {
10098 sample.source == format!("command:{}", TEST_COMMAND.name())
10099 && sample.reason.as_deref() == Some("test command changed presentation")
10100 }));
10101 }
10102
10103 #[test]
10104 fn focused_command_without_focus_is_dropped_instead_of_targeting_the_root() {
10105 let commands = Arc::new(AtomicUsize::new(0));
10106 let mut runtime = Application::new()
10107 .window(WindowBuilder::new().root(CommandRoot {
10108 commands: Arc::clone(&commands),
10109 custom_events: Arc::new(AtomicUsize::new(0)),
10110 }))
10111 .build()
10112 .unwrap();
10113 let window_id = runtime.window_ids()[0];
10114 runtime.render(window_id).unwrap();
10115
10116 runtime
10117 .command_sender()
10118 .send_focused(window_id, TEST_COMMAND, 1);
10119 runtime.process_commands();
10120 let output = runtime.render(window_id).unwrap();
10121
10122 assert_eq!(commands.load(Ordering::Relaxed), 0);
10123 assert!(output.diagnostics.command_dispatches.iter().any(|sample| {
10124 sample.name == TEST_COMMAND.name()
10125 && sample.target == CommandTarget::FocusedWidget(window_id)
10126 && !sample.delivered
10127 }));
10128 }
10129
10130 #[test]
10131 fn runtime_render_reports_ime_composition_rect_for_shaped_text_widgets() {
10132 let (mut runtime, window_id) = build_text_runtime();
10133 set_window_scene_statistics_detail_mode(window_id, SceneStatisticsDetailMode::Detailed);
10134
10135 let output = runtime.render(window_id).unwrap();
10136
10137 assert!(output.ime_composition_rect.is_some());
10138 assert!(output.diagnostics.text_caches.runtime_layout.misses > 0);
10139 assert!(!output.frame.scene.commands().is_empty());
10140 let mut saw_shaped_text = false;
10141 output.frame.scene.visit_commands(&mut |command| {
10142 if matches!(command, sui_scene::SceneCommand::DrawShapedText(_)) {
10143 saw_shaped_text = true;
10144 }
10145 });
10146 assert!(saw_shaped_text);
10147 }
10148
10149 #[test]
10150 fn browser_back_clears_ime_focus_before_becoming_unhandled() {
10151 let mut runtime = Application::new()
10152 .window(
10153 WindowBuilder::new()
10154 .title("Browser Back IME")
10155 .root(PaintedChildRoot::new(FocusedImeLeaf)),
10156 )
10157 .build()
10158 .unwrap();
10159 let window_id = runtime.window_ids()[0];
10160 let initial = runtime.render(window_id).unwrap();
10161 let text_input = initial
10162 .semantics
10163 .iter()
10164 .find(|node| node.role == SemanticsRole::TextInput)
10165 .expect("focused IME test input")
10166 .id;
10167
10168 assert!(
10169 runtime
10170 .handle_semantics_action(window_id, text_input, SemanticsActionRequest::Focus)
10171 .unwrap()
10172 );
10173 assert!(
10174 runtime
10175 .render(window_id)
10176 .unwrap()
10177 .ime_composition_rect
10178 .is_some()
10179 );
10180
10181 assert!(
10182 runtime
10183 .dispatch_event(
10184 window_id,
10185 Event::Keyboard(KeyboardEvent::new("BrowserBack", KeyState::Pressed)),
10186 )
10187 .unwrap()
10188 );
10189 assert_eq!(runtime.focused_widget(window_id).unwrap(), None);
10190 assert!(
10191 runtime
10192 .render(window_id)
10193 .unwrap()
10194 .ime_composition_rect
10195 .is_none()
10196 );
10197
10198 assert!(
10199 !runtime
10200 .dispatch_event(
10201 window_id,
10202 Event::Keyboard(KeyboardEvent::new("BrowserBack", KeyState::Pressed)),
10203 )
10204 .unwrap()
10205 );
10206 }
10207
10208 #[test]
10209 fn dispatch_event_reports_widget_handled_browser_back() {
10210 let (mut runtime, window_id, _, leaf_counters) = build_runtime();
10211 let initial = runtime.render(window_id).unwrap();
10212 let focus_leaf = initial
10213 .semantics
10214 .iter()
10215 .find(|node| node.name.as_deref() == Some("focus-leaf"))
10216 .expect("focus leaf")
10217 .id;
10218 assert!(
10219 runtime
10220 .handle_semantics_action(window_id, focus_leaf, SemanticsActionRequest::Focus)
10221 .unwrap()
10222 );
10223
10224 assert!(
10225 runtime
10226 .dispatch_event(
10227 window_id,
10228 Event::Keyboard(KeyboardEvent::new("BrowserBack", KeyState::Pressed)),
10229 )
10230 .unwrap()
10231 );
10232 assert_eq!(leaf_counters.borrow().keyboard, 1);
10233 }
10234
10235 #[test]
10236 fn text_layout_retention_follows_retained_scene_handles() {
10237 let system = TextSystem::new();
10238 let first = system
10239 .shape_text_persistent(
10240 None,
10241 "first",
10242 Size::new(120.0, 24.0),
10243 TextStyle::new(Color::WHITE),
10244 &sui_text::FontRegistry::new(),
10245 )
10246 .unwrap();
10247 let second = system
10248 .shape_text_persistent(
10249 None,
10250 "second",
10251 Size::new(120.0, 24.0),
10252 TextStyle::new(Color::WHITE),
10253 &sui_text::FontRegistry::new(),
10254 )
10255 .unwrap();
10256
10257 let mut scene = Scene::new();
10258 scene.push(SceneCommand::DrawShapedText(sui_text::ShapedText::new(
10259 Point::ZERO,
10260 &first,
10261 )));
10262 super::retain_text_layouts_for_scene(&system, &scene);
10263
10264 let registry = system.text_layout_registry();
10265 assert!(registry.contains(first.handle()));
10266 assert!(!registry.contains(second.handle()));
10267 }
10268
10269 #[test]
10270 fn removing_a_window_tears_down_runtime_state() {
10271 let (mut runtime, window_id, _, _) = build_runtime();
10272 set_window_render_options(window_id, WindowRenderOptions::new(false, 1.0));
10273 assert!(window_render_options(window_id).is_some());
10274
10275 runtime.remove_window(window_id).unwrap();
10276
10277 assert!(runtime.window_ids().is_empty());
10278 assert!(window_render_options(window_id).is_none());
10279 assert!(runtime.needs_render(window_id).is_err());
10280 assert!(runtime.focus_state(window_id).is_err());
10281 assert!(runtime.render(window_id).is_err());
10282 }
10283}