1#![forbid(unsafe_code)]
2
3mod app;
4mod command;
5mod command_history;
6mod diagnostics;
7mod layout_work;
8mod logo;
9mod measure_cache;
10mod motion;
11mod output_cache;
12mod output_range;
13mod overlay;
14mod reactive;
15mod resources;
16use resources::ResourceStore;
17mod widget;
18
19use std::{
20 collections::{BTreeSet, HashMap, HashSet, VecDeque},
21 sync::{
22 Arc,
23 atomic::{AtomicU64, Ordering},
24 },
25};
26
27use rustc_hash::{FxHashMap, FxHashSet};
28
29use sui_core::{
30 AsyncWakeToken, Clipboard, ClipboardBackend, CursorGrabMode, CustomEvent, DirtyRegion,
31 DragEvent, DragEventKind, DragOutcome, DragPayload, DragScopeId, DragSessionId, DropEffect,
32 DropEffects, Error, Event, FontHandle, ImageHandle, InvalidationKind, InvalidationRequest,
33 InvalidationTarget, KeyState, KeyboardEvent, Modifiers, Point, PointerButton, PointerButtons,
34 PointerEvent, PointerEventKind, PointerKind, Rect, Result, SemanticsActionRequest,
35 SemanticsEvent, SemanticsNode, Size, TimerToken, Transform, UrlOpener, UrlOpenerBackend,
36 Vector, WakeEvent, WidgetId, WindowEvent, WindowId,
37};
38use sui_layout::Constraints;
39use sui_scene::{
40 ImageRegistry, LayerCompositionMode, RegisteredImage, Scene, SceneCommand, SceneFrame,
41 SceneLayer, SceneLayerDescriptor, SceneLayerUpdate, SceneLayerUpdateKind,
42};
43use sui_text::{FontRegistry, RegisteredFont, TextLayoutHandle, TextSystem};
44use web_time::Instant;
45
46pub use app::{Application, EmbeddedSvgImageResource, WindowBuilder, WindowIcon};
47pub use command::{
48 Command, CommandController, CommandCtx, CommandDelivery, CommandKey, CommandSender,
49 CommandTarget,
50};
51use command::{CommandInvalidation, CommandListeners, QueuedCommand};
52pub use command_history::{COMMAND_HISTORY_LENGTH, window_command_dispatches_signal};
53pub use diagnostics::{
54 CacheMetrics, CacheMetricsDelta, CommandDispatchSample, FramePhase, FramePhaseSample,
55 InvalidationTraceSample, PresentationLatencyDiagnostics, ReactiveInvalidationSample,
56 RenderDiagnostics, RendererSubmissionDiagnostics, RetainedPacketHotspotDiagnostics,
57 RetainedPacketRebuildDiagnostics, SceneStatistics, SceneStatisticsDetailMode,
58 TextCacheDeltaDiagnostics, TextCacheDiagnostics, WidgetRebuildSample, WidgetTimingPhase,
59 WidgetTimingSample, WindowColorManagementMode, WindowDynamicRangeMode,
60 WindowOutputColorPrimaries, WindowPerformanceSnapshot, WindowPerformanceSummary,
61 WindowRenderOptions, WindowStemDarkening, WindowTextCoveragePolicy, WindowTextHinting,
62 WindowTextSubpixelOrder, WindowToneMappingMode, clear_window_performance_snapshot,
63 clear_window_performance_snapshots, clear_window_render_options,
64 publish_window_performance_snapshot, set_window_render_options,
65 set_window_scene_statistics_detail_mode, window_performance_snapshot,
66 window_performance_summary, window_performance_text_caches, window_render_options,
67 window_scene_statistics_detail_mode,
68};
69#[doc(hidden)]
70pub use layout_work::record_scrollbar_gutter_iteration;
71pub use layout_work::{
72 LayoutWorkSnapshot, begin_layout_work_collection, take_layout_work_collection,
73};
74pub use logo::{DEFAULT_SUI_LOGO_SVG, default_sui_logo_image};
75pub use motion::{
76 AnimateCtx, FrameClock, FramePacing, Motion, app_motion_preference, motion_policy,
77 motion_time_scale, reset_motion_settings, set_app_motion_preference, set_motion_time_scale,
78 set_system_motion_preference, system_motion_preference,
79};
80pub use output_range::{
81 OutputColorRange, set_window_output_color_range, window_output_color_range,
82 window_output_color_range_signal,
83};
84pub use overlay::{
85 OVERLAY_DISMISS_REQUEST, OverlayDismissPolicy, OverlayDismissReason, OverlayDismissRequest,
86 OverlayFocusBehavior, OverlayInitialFocus, OverlayKind, OverlayManagerSnapshot,
87 OverlayModality, OverlayOptions, OverlaySnapshot, OverlayTraceKind, OverlayTraceSample,
88};
89use std::rc::Rc;
90pub use sui_core::{DpiInfo, MotionPolicy, MotionPreference, SafeAreaInsets};
91pub use sui_layout::LayoutContext;
92pub use widget::{
93 ArrangeCtx, EventCtx, EventPhase, FocusRestorePolicy, FocusScope, FocusScopeState,
94 KeyedChildren, KeyedReconcile, LayerOptions, MeasureCtx, PaintBoundaryMode, PaintCtx,
95 SemanticsCtx, SingleChild, StackHostOptions, StackOrderPolicy, StackSurfaceOptions, Widget,
96 WidgetChildren, WidgetDiagnostic, WidgetDiagnosticsCtx, WidgetDiagnosticsSnapshot, WidgetPod,
97 WidgetPodMutVisitor, WidgetPodVisitor,
98};
99use widget::{ArrangeScope, MeasureScope};
100use widget::{
101 BeginDragRequest, CursorRequest, DragRequest, DropAcceptanceRequest, FocusRequest,
102 HostServices, PaintImageResource, PointerCaptureRequest, WakeRequest,
103};
104
105pub const REACTIVE_CHANGED: CommandKey<()> = CommandKey::new("sui.reactive.changed");
108
109type PaintOutput = (
110 Scene,
111 Vec<(ImageHandle, PaintImageResource)>,
112 FxHashMap<WidgetId, Rect>,
113 Option<Rect>,
114);
115
116static NEXT_WINDOW_ID: AtomicU64 = AtomicU64::new(1);
117
118pub const EXTERNAL_WAKE_KIND: &str = "sui.external.wake";
121
122pub struct Runtime {
123 resources: ResourceStore,
124 text_system: Arc<TextSystem>,
125 services: HostServices,
126 windows: Vec<WindowState>,
127 external_waker: Option<Arc<dyn Fn() + Send + Sync>>,
128 command_sender: CommandSender,
129 command_listeners: CommandListeners,
130}
131
132#[cfg(feature = "layout-diagnostics")]
135pub fn begin_frame_timing_collection() {
136 diagnostics::begin_widget_timing_collection();
137 sui_text::begin_text_timing_collection();
138}
139
140impl Runtime {
141 pub fn new() -> Self {
142 Self::with_resources(ResourceStore::default())
143 }
144
145 fn with_resources(resources: ResourceStore) -> Self {
146 Self {
147 resources,
148 text_system: Arc::new(TextSystem::new()),
149 services: HostServices::default(),
150 windows: Vec::new(),
151 external_waker: None,
152 command_sender: CommandSender::new(),
153 command_listeners: CommandListeners::default(),
154 }
155 }
156
157 pub fn add_window(&mut self, builder: WindowBuilder) -> Result<WindowId> {
158 let window_id = self.alloc_window_id();
159 let mut window = builder.build(window_id, self.command_sender.clone())?;
160 window.services = self.services.clone();
161 window.reactive_hub.set_waker(self.external_waker.clone());
162 self.windows.push(window);
163 Ok(window_id)
164 }
165
166 pub fn set_external_waker(&mut self, waker: impl Fn() + Send + Sync + 'static) {
169 let waker: Arc<dyn Fn() + Send + Sync> = Arc::new(waker);
170 self.external_waker = Some(Arc::clone(&waker));
171 for window in &self.windows {
172 window.reactive_hub.set_waker(Some(Arc::clone(&waker)));
173 }
174 }
175
176 pub fn set_command_waker(&self, waker: impl Fn() + Send + Sync + 'static) {
178 self.command_sender.set_waker(Some(Arc::new(waker)));
179 }
180
181 pub fn command_sender(&self) -> CommandSender {
183 self.command_sender.clone()
184 }
185
186 pub fn has_pending_commands(&self) -> bool {
187 self.command_sender.has_pending()
188 }
189
190 pub fn exit_requested(&self) -> bool {
193 self.command_sender.exit_requested()
194 }
195
196 pub fn process_reactive_updates(&mut self) {
201 for window in &mut self.windows {
202 window.drain_reactive_invalidations();
203 }
204 }
205
206 pub fn process_commands(&mut self) {
211 const MAX_COMMAND_ROUNDS: usize = 8;
212
213 for _ in 0..MAX_COMMAND_ROUNDS {
214 let (manual_wake, commands) = self.command_sender.drain();
215 if !manual_wake && commands.is_empty() {
216 break;
217 }
218 if manual_wake {
219 self.dispatch_controller_wake();
220 }
221 for command in commands {
222 self.dispatch_queued_command(&command);
223 }
224 }
225 }
226
227 pub fn handle_command<T>(
230 &mut self,
231 target: CommandTarget,
232 delivery: CommandDelivery,
233 key: CommandKey<T>,
234 payload: T,
235 ) where
236 T: Send + Sync + 'static,
237 {
238 match delivery {
239 CommandDelivery::Directed => self.command_sender.send(target, key, payload),
240 CommandDelivery::Broadcast => self.command_sender.broadcast(target, key, payload),
241 };
242 self.process_commands();
243 }
244
245 pub fn clipboard(&self) -> Clipboard {
247 self.services.clipboard.clone()
248 }
249
250 pub fn set_clipboard_backend(&self, backend: impl ClipboardBackend + 'static) {
253 self.services.clipboard.set_backend(backend);
254 }
255
256 pub fn url_opener(&self) -> UrlOpener {
259 self.services.url_opener.clone()
260 }
261
262 pub fn set_url_opener_backend(&self, backend: impl UrlOpenerBackend + 'static) {
265 self.services.url_opener.set_backend(backend);
266 }
267
268 pub fn remove_window(&mut self, window_id: WindowId) -> Result<()> {
269 let Some(window_index) = self
270 .windows
271 .iter()
272 .position(|window| window.id == window_id)
273 else {
274 return Err(Error::new(format!(
275 "window {} does not exist",
276 window_id.get()
277 )));
278 };
279
280 self.windows.remove(window_index);
281 clear_window_performance_snapshot(window_id);
282 Ok(())
283 }
284
285 pub fn handle_event(&mut self, window_id: WindowId, event: Event) -> Result<()> {
286 self.dispatch_event(window_id, event).map(|_| ())
287 }
288
289 pub fn dispatch_event(&mut self, window_id: WindowId, event: Event) -> Result<bool> {
296 let text_system = Arc::clone(&self.text_system);
297 let font_registry = Arc::clone(self.resources.fonts());
298 let image_registry = Arc::clone(self.resources.images());
299 let window = self.window_mut(window_id)?;
300 window.drain_reactive_invalidations();
301 let handled = window.handle_event(event, text_system, font_registry, image_registry);
302 window.drain_reactive_invalidations();
303 Ok(handled)
304 }
305
306 pub fn handle_semantics_action(
315 &mut self,
316 window_id: WindowId,
317 target: WidgetId,
318 action: SemanticsActionRequest,
319 ) -> Result<bool> {
320 let text_system = Arc::clone(&self.text_system);
321 let font_registry = Arc::clone(self.resources.fonts());
322 let image_registry = Arc::clone(self.resources.images());
323 let window = self.window_mut(window_id)?;
324 Ok(window.handle_semantics_action(
325 target,
326 action,
327 text_system,
328 font_registry,
329 image_registry,
330 ))
331 }
332
333 pub fn tick(&mut self, frame_time: f64) {
334 for window in &mut self.windows {
335 window.last_tick_time = frame_time;
336 }
337 }
338
339 pub fn drain_ready_events(&mut self) -> Vec<(WindowId, Event)> {
340 let mut ready = Vec::new();
341
342 for window in &mut self.windows {
343 let window_id = window.id;
344 ready.extend(
345 window
346 .drain_ready_events()
347 .into_iter()
348 .map(|event| (window_id, event)),
349 );
350 }
351
352 ready
353 }
354
355 pub fn next_wakeup_time(&self, window_id: WindowId) -> Result<Option<f64>> {
356 let window = self.window(window_id)?;
357 Ok(window.next_wakeup_time())
358 }
359
360 pub fn has_pending_animation_frames(&self, window_id: WindowId) -> Result<bool> {
363 let window = self.window(window_id)?;
364 Ok(window.active_animated_widget_count() > 0)
365 }
366
367 pub fn set_frame_pacing(&mut self, window_id: WindowId, pacing: FramePacing) -> Result<()> {
371 self.window_mut(window_id)?.frame_pacing = pacing;
372 Ok(())
373 }
374
375 pub fn frame_pacing(&self, window_id: WindowId) -> Result<FramePacing> {
376 Ok(self.window(window_id)?.frame_pacing)
377 }
378
379 pub fn begin_animation_frame(
384 &mut self,
385 window_id: WindowId,
386 frame_time: f64,
387 ) -> Result<Vec<Event>> {
388 Ok(self
389 .window_mut(window_id)?
390 .begin_animation_frame(frame_time))
391 }
392
393 pub fn wake_async(&mut self, window_id: WindowId, token: AsyncWakeToken) -> Result<bool> {
394 let window = self.window_mut(window_id)?;
395 Ok(window.wake_async(token))
396 }
397
398 pub fn wake_root(&mut self, window_id: WindowId) -> Result<()> {
404 self.handle_event(
405 window_id,
406 Event::Custom(CustomEvent::new(EXTERNAL_WAKE_KIND)),
407 )
408 }
409
410 pub fn register_font(&mut self, handle: FontHandle, font: RegisteredFont) -> Result<()> {
411 self.resources.register_font(handle, font)
412 }
413
414 pub fn register_font_bytes(&mut self, data: impl Into<Vec<u8>>) -> Result<FontHandle> {
415 self.resources.register_font_bytes(data)
416 }
417
418 pub fn register_image(&mut self, handle: ImageHandle, image: RegisteredImage) -> Result<()> {
419 self.resources.register_image(handle, image)
420 }
421
422 pub fn register_svg_image_with_handle(
423 &mut self,
424 handle: ImageHandle,
425 data: impl AsRef<[u8]>,
426 ) -> Result<()> {
427 self.resources.register_svg_image_with_handle(handle, data)
428 }
429
430 pub fn register_rgba_image(
431 &mut self,
432 width: u32,
433 height: u32,
434 data: impl Into<Vec<u8>>,
435 ) -> Result<ImageHandle> {
436 self.resources.register_rgba_image(width, height, data)
437 }
438
439 pub fn register_svg_image(&mut self, data: impl AsRef<[u8]>) -> Result<ImageHandle> {
440 self.resources.register_svg_image(data)
441 }
442
443 pub fn register_svg_image_at_size_with_handle(
444 &mut self,
445 handle: ImageHandle,
446 width: u32,
447 height: u32,
448 data: impl AsRef<[u8]>,
449 ) -> Result<()> {
450 self.resources
451 .register_svg_image_at_size_with_handle(handle, width, height, data)
452 }
453
454 pub fn register_svg_image_at_size(
455 &mut self,
456 width: u32,
457 height: u32,
458 data: impl AsRef<[u8]>,
459 ) -> Result<ImageHandle> {
460 self.resources
461 .register_svg_image_at_size(width, height, data)
462 }
463
464 pub fn register_embedded_svg_image(
465 &mut self,
466 resource: EmbeddedSvgImageResource,
467 ) -> Result<()> {
468 self.resources.register_embedded_svg_image(resource)
469 }
470
471 pub fn register_embedded_svg_images(
472 &mut self,
473 resources: impl IntoIterator<Item = EmbeddedSvgImageResource>,
474 ) -> Result<()> {
475 self.resources.register_embedded_svg_images(resources)
476 }
477
478 pub fn font_registry(&self) -> &Arc<FontRegistry> {
479 self.resources.fonts()
480 }
481
482 pub fn text_preparation_cache_snapshot(&self) -> sui_text::TextPreparationCacheSnapshot {
484 self.text_system.preparation_cache_snapshot()
485 }
486
487 pub fn image_registry(&self) -> &Arc<ImageRegistry> {
488 self.resources.images()
489 }
490
491 pub fn render(&mut self, window_id: WindowId) -> Result<RenderOutput> {
492 let text_system = Arc::clone(&self.text_system);
493 let font_registry = Arc::clone(self.resources.fonts());
494 let image_registry = Arc::clone(self.resources.images());
495 let window = self.window_mut(window_id)?;
496 window.repaint_for_render_options();
497 window.drain_reactive_invalidations();
498 Ok(window.render(text_system, font_registry, image_registry))
499 }
500
501 pub fn semantics(&self, window_id: WindowId) -> Result<&[SemanticsNode]> {
502 let window = self.window(window_id)?;
503 Ok(&window.last_semantics)
504 }
505
506 pub fn window_title(&self, window_id: WindowId) -> Result<&str> {
507 let window = self.window(window_id)?;
508 Ok(&window.title)
509 }
510
511 pub fn window_icon(&self, window_id: WindowId) -> Result<Option<&WindowIcon>> {
512 let window = self.window(window_id)?;
513 Ok(window.icon.as_ref())
514 }
515
516 pub fn window_ids(&self) -> Vec<WindowId> {
517 self.windows.iter().map(|window| window.id).collect()
518 }
519
520 pub fn needs_render(&self, window_id: WindowId) -> Result<bool> {
521 let window = self.window(window_id)?;
522 Ok(window.needs_render())
523 }
524
525 pub fn schedule(&self, window_id: WindowId) -> Result<FrameSchedule> {
526 let window = self.window(window_id)?;
527 Ok(window.schedule)
528 }
529
530 pub fn focus_state(&self, window_id: WindowId) -> Result<FocusState> {
531 let window = self.window(window_id)?;
532 Ok(window.focus)
533 }
534
535 pub fn focused_widget(&self, window_id: WindowId) -> Result<Option<WidgetId>> {
536 Ok(self.focus_state(window_id)?.focused_widget)
537 }
538
539 pub fn pointer_capture_target(
540 &self,
541 window_id: WindowId,
542 pointer_id: u64,
543 ) -> Result<Option<WidgetId>> {
544 let window = self.window(window_id)?;
545 Ok(window.pointer_capture.get(&pointer_id).copied())
546 }
547
548 pub fn window_initial_size(&self, window_id: WindowId) -> Result<Option<Size>> {
550 Ok(self.window(window_id)?.initial_size)
551 }
552
553 pub fn window_initial_position(&self, window_id: WindowId) -> Result<Option<Point>> {
555 Ok(self.window(window_id)?.initial_position)
556 }
557
558 pub fn window_cursor_state(&self, window_id: WindowId) -> Result<WindowCursorState> {
564 Ok(self.window(window_id)?.cursor.state)
565 }
566
567 pub fn widget_graph(&self, window_id: WindowId) -> Result<WidgetGraphSnapshot> {
568 let window = self.window(window_id)?;
569 Ok(window.graph.snapshot())
570 }
571
572 pub fn set_inspector_tracing(&mut self, window_id: WindowId, enabled: bool) -> Result<()> {
575 let window = self.window_mut(window_id)?;
576 if window.inspector_tracing_enabled != enabled {
577 window.clear_inspector_history();
578 window.last_render_diagnostics = RenderDiagnostics::default();
579 }
580 window.inspector_tracing_enabled = enabled;
581 Ok(())
582 }
583
584 pub fn inspector_tracing(&self, window_id: WindowId) -> Result<bool> {
585 Ok(self.window(window_id)?.inspector_tracing_enabled)
586 }
587
588 pub fn inspector_snapshot(&self, window_id: WindowId) -> Result<WindowInspectorSnapshot> {
590 let window = self.window(window_id)?;
591 Ok(window.inspector_snapshot())
592 }
593
594 pub fn overlay_snapshot(&self, window_id: WindowId) -> Result<OverlayManagerSnapshot> {
596 let window = self.window(window_id)?;
597 Ok(window.overlay_manager.snapshot())
598 }
599
600 pub fn take_overlay_traces(&mut self, window_id: WindowId) -> Result<Vec<OverlayTraceSample>> {
602 let window = self.window_mut(window_id)?;
603 Ok(window.overlay_manager.take_traces())
604 }
605
606 fn dispatch_controller_wake(&mut self) {
607 let sender = self.command_sender.clone();
608 let mut app_ctx = CommandCtx::new(sender.clone(), None);
609 let app_handlers = self.command_listeners.wake(&mut app_ctx);
610 self.apply_command_ctx(
611 app_ctx,
612 "scheduler wake",
613 "()",
614 None,
615 0,
616 CommandTarget::Application,
617 CommandDelivery::Broadcast,
618 app_handlers,
619 );
620
621 for index in 0..self.windows.len() {
622 let window_id = self.windows[index].id;
623 let mut ctx = CommandCtx::new(sender.clone(), Some(window_id));
624 let handlers = self.windows[index].command_listeners.wake(&mut ctx);
625 self.apply_command_ctx(
626 ctx,
627 "scheduler wake",
628 "()",
629 Some(index),
630 0,
631 CommandTarget::Window(window_id),
632 CommandDelivery::Broadcast,
633 handlers,
634 );
635 }
636 }
637
638 fn dispatch_queued_command(&mut self, queued: &QueuedCommand) {
639 match queued.target {
640 CommandTarget::Widget {
641 window_id,
642 widget_id,
643 } => {
644 if let Some(index) = self
645 .windows
646 .iter()
647 .position(|window| window.id == window_id)
648 {
649 let Some(dispatch) =
650 self.windows[index].dispatch_direct_command(widget_id, queued)
651 else {
652 self.windows[index].record_command_dispatch(command_sample(
653 queued,
654 Vec::new(),
655 false,
656 false,
657 ));
658 return;
659 };
660 let (handlers, handled) = {
661 let handled = dispatch.handled;
662 (vec!["widget target".to_string()], handled)
663 };
664 let focus_request = dispatch.focus_request;
665 let mut effects = EventEffects::default();
666 effects.extend(dispatch);
667 let mut invalidations = Vec::new();
668 self.windows[index].apply_event_effects(effects, &mut invalidations);
669 if let Some(request) = focus_request {
670 let focus_effects = self.windows[index].apply_focus_request(request);
671 self.windows[index].apply_event_effects(focus_effects, &mut invalidations);
672 }
673 self.windows[index].record_command_invalidations(
674 &invalidations,
675 queued.key.name,
676 None,
677 );
678 self.windows[index].schedule.extend(&invalidations);
679 self.windows[index]
680 .pending_invalidations
681 .extend(invalidations);
682 self.windows[index]
683 .record_command_dispatch(command_sample(queued, handlers, handled, true));
684 }
685 }
686 CommandTarget::FocusedWidget(window_id) => {
687 if let Some(index) = self
688 .windows
689 .iter()
690 .position(|window| window.id == window_id)
691 {
692 let Some(target) = self.windows[index].focus.focused_widget else {
693 self.windows[index].record_command_dispatch(command_sample(
694 queued,
695 Vec::new(),
696 false,
697 false,
698 ));
699 return;
700 };
701 let Some(dispatch) =
702 self.windows[index].dispatch_direct_command(target, queued)
703 else {
704 self.windows[index].record_command_dispatch(command_sample(
705 queued,
706 Vec::new(),
707 false,
708 false,
709 ));
710 return;
711 };
712 let handled = { dispatch.handled };
713 let focus_request = dispatch.focus_request;
714 let mut effects = EventEffects::default();
715 effects.extend(dispatch);
716 let mut invalidations = Vec::new();
717 self.windows[index].apply_event_effects(effects, &mut invalidations);
718 if let Some(request) = focus_request {
719 let focus_effects = self.windows[index].apply_focus_request(request);
720 self.windows[index].apply_event_effects(focus_effects, &mut invalidations);
721 }
722 self.windows[index].record_command_invalidations(
723 &invalidations,
724 queued.key.name,
725 None,
726 );
727 self.windows[index].schedule.extend(&invalidations);
728 self.windows[index]
729 .pending_invalidations
730 .extend(invalidations);
731 self.windows[index].record_command_dispatch(command_sample(
732 queued,
733 vec!["focused widget".to_string()],
734 handled,
735 true,
736 ));
737 }
738 }
739 CommandTarget::Window(window_id) => {
740 if let Some(index) = self
741 .windows
742 .iter()
743 .position(|window| window.id == window_id)
744 {
745 self.dispatch_to_window_listeners(index, queued);
746 }
747 }
748 CommandTarget::Application => {
749 let sender = self.command_sender.clone();
750 let mut ctx = CommandCtx::new(sender.clone(), None);
751 let broadcast = queued.delivery == CommandDelivery::Broadcast;
752 let command = Command::new(queued);
753 let handlers = self
754 .command_listeners
755 .dispatch(&mut ctx, &command, broadcast);
756 self.apply_command_ctx(
757 ctx,
758 queued.key.name,
759 queued.key.payload_type_name,
760 None,
761 queued.sequence,
762 queued.target,
763 queued.delivery,
764 handlers,
765 );
766
767 if broadcast {
768 for index in 0..self.windows.len() {
769 self.dispatch_to_window_listeners(index, queued);
770 }
771 }
772 }
773 }
774 }
775
776 fn dispatch_to_window_listeners(&mut self, index: usize, queued: &QueuedCommand) {
777 let sender = self.command_sender.clone();
778 let window_id = self.windows[index].id;
779 let mut ctx = CommandCtx::new(sender, Some(window_id));
780 let broadcast = queued.delivery == CommandDelivery::Broadcast;
781 let command = Command::new(queued);
782 let handlers = self.windows[index]
783 .command_listeners
784 .dispatch(&mut ctx, &command, broadcast);
785 self.apply_command_ctx(
786 ctx,
787 queued.key.name,
788 queued.key.payload_type_name,
789 Some(index),
790 queued.sequence,
791 queued.target,
792 queued.delivery,
793 handlers,
794 );
795 }
796
797 #[allow(clippy::too_many_arguments)]
798 fn apply_command_ctx(
799 &mut self,
800 mut ctx: CommandCtx,
801 source: &str,
802 payload_type: &str,
803 delivery_window: Option<usize>,
804 sequence: u64,
805 target: CommandTarget,
806 delivery: CommandDelivery,
807 handlers: Vec<String>,
808 ) {
809 let handled = ctx.is_handled();
810 let invalidations = ctx.take_invalidations();
811 let every_window_invalidations = ctx.take_every_window_invalidations();
812 let animations = ctx.take_animation_targets();
813 for invalidation in invalidations {
814 self.apply_command_invalidation(invalidation, source, delivery_window);
815 }
816 for invalidation in every_window_invalidations {
817 for window_id in self.window_ids() {
818 let mut request = InvalidationRequest::new(
819 InvalidationTarget::Window(window_id),
820 invalidation.kind,
821 );
822 if let Some(region) = invalidation.region {
823 request = request.with_region(region);
824 }
825 self.apply_command_invalidation(
826 CommandInvalidation {
827 request,
828 reason: invalidation.reason.clone(),
829 },
830 source,
831 delivery_window,
832 );
833 }
834 }
835 for (window_id, widget_id) in animations {
836 if let Some(window) = self.windows.iter_mut().find(|window| match window_id {
837 Some(window_id) => window.id == window_id,
838 None => window.root.id() == widget_id || window.graph.contains(widget_id),
839 }) {
840 window.requested_animation_frames.insert(widget_id);
841 }
842 }
843
844 let sample = CommandDispatchSample {
845 sequence,
846 name: source.to_string(),
847 payload_type: payload_type.to_string(),
848 target,
849 delivery,
850 delivered: !handlers.is_empty(),
851 handlers,
852 handled,
853 };
854 if let Some(index) = delivery_window {
855 self.windows[index].record_command_dispatch(sample);
856 } else {
857 for window in &mut self.windows {
858 window.record_command_dispatch(sample.clone());
859 }
860 }
861 }
862
863 fn apply_command_invalidation(
864 &mut self,
865 invalidation: CommandInvalidation,
866 source: &str,
867 delivery_window: Option<usize>,
868 ) {
869 let target_index = match invalidation.request.target {
870 InvalidationTarget::Window(window_id) => self
871 .windows
872 .iter()
873 .position(|window| window.id == window_id),
874 InvalidationTarget::Widget(widget_id) => self.windows.iter().position(|window| {
875 window.root.id() == widget_id || window.graph.contains(widget_id)
876 }),
877 InvalidationTarget::Surface(_) => delivery_window,
878 };
879 let Some(index) = target_index else {
880 return;
881 };
882 let request = invalidation.request;
883 push_trace(
884 &mut self.windows[index].pending_invalidation_diagnostics,
885 InvalidationTraceSample {
886 target: request.target,
887 kind: request.kind,
888 region: request.region,
889 source: format!("command:{source}"),
890 reason: invalidation.reason,
891 },
892 );
893 self.windows[index]
894 .schedule
895 .extend(std::slice::from_ref(&request));
896 self.windows[index].pending_invalidations.push(request);
897 }
898
899 fn alloc_window_id(&mut self) -> WindowId {
900 WindowId::new(NEXT_WINDOW_ID.fetch_add(1, Ordering::Relaxed))
901 }
902
903 fn window(&self, window_id: WindowId) -> Result<&WindowState> {
904 self.windows
905 .iter()
906 .find(|window| window.id == window_id)
907 .ok_or_else(|| Error::new(format!("window {} does not exist", window_id.get())))
908 }
909
910 fn window_mut(&mut self, window_id: WindowId) -> Result<&mut WindowState> {
911 self.windows
912 .iter_mut()
913 .find(|window| window.id == window_id)
914 .ok_or_else(|| Error::new(format!("window {} does not exist", window_id.get())))
915 }
916}
917
918impl Default for Runtime {
919 fn default() -> Self {
920 Self::new()
921 }
922}
923
924#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
925pub struct FocusState {
926 pub focused_widget: Option<WidgetId>,
927 pub window_focused: bool,
928}
929
930#[derive(Debug, Clone, Copy, PartialEq, Eq)]
936pub struct WindowCursorState {
937 pub grab_mode: CursorGrabMode,
938 pub visible: bool,
939 pub revision: u64,
940}
941
942impl Default for WindowCursorState {
943 fn default() -> Self {
944 Self {
945 grab_mode: CursorGrabMode::None,
946 visible: true,
947 revision: 0,
948 }
949 }
950}
951
952#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
953pub struct FrameSchedule {
954 pub measure: bool,
955 pub arrange: bool,
956 pub ordering: bool,
957 pub paint: bool,
958 pub semantics: bool,
959 pub hit_test: bool,
960 pub text: bool,
961 pub resources: bool,
962}
963
964impl FrameSchedule {
965 fn bootstrap() -> Self {
966 Self {
967 measure: true,
968 arrange: true,
969 ordering: false,
970 paint: true,
971 semantics: true,
972 hit_test: true,
973 text: false,
974 resources: false,
975 }
976 }
977
978 pub const fn any(self) -> bool {
979 self.measure
980 || self.arrange
981 || self.ordering
982 || self.paint
983 || self.semantics
984 || self.hit_test
985 || self.text
986 || self.resources
987 }
988
989 pub const fn needs_render(self) -> bool {
990 self.measure
991 || self.arrange
992 || self.ordering
993 || self.paint
994 || self.semantics
995 || self.text
996 || self.resources
997 }
998
999 fn clear(&mut self) {
1000 *self = Self::default();
1001 }
1002
1003 fn mark(&mut self, kind: InvalidationKind) {
1004 match kind {
1005 InvalidationKind::Measure => {
1006 self.measure = true;
1007 self.arrange = true;
1008 self.ordering = true;
1009 self.paint = true;
1010 self.hit_test = true;
1011 self.semantics = true;
1012 }
1013 InvalidationKind::Arrange
1014 | InvalidationKind::Transform
1015 | InvalidationKind::Clip
1016 | InvalidationKind::Visibility => {
1017 self.ordering = true;
1018 self.arrange = true;
1019 self.paint = true;
1020 self.hit_test = true;
1021 self.semantics = true;
1022 }
1023 InvalidationKind::Ordering => {
1024 self.ordering = true;
1025 self.hit_test = true;
1026 }
1027 InvalidationKind::Effect => {
1028 self.paint = true;
1029 }
1030 InvalidationKind::Paint => {
1031 self.paint = true;
1032 }
1033 InvalidationKind::HitTest => {
1034 self.hit_test = true;
1035 }
1036 InvalidationKind::Text => {
1037 self.text = true;
1038 self.measure = true;
1039 self.arrange = true;
1040 self.paint = true;
1041 self.semantics = true;
1042 }
1043 InvalidationKind::Semantics => {
1044 self.semantics = true;
1045 }
1046 InvalidationKind::Resources => {
1047 self.resources = true;
1048 self.paint = true;
1049 }
1050 }
1051 }
1052
1053 fn extend(&mut self, invalidations: &[InvalidationRequest]) {
1054 for request in invalidations {
1055 self.mark(request.kind);
1056 }
1057 }
1058}
1059
1060#[derive(Debug, Clone, PartialEq)]
1061pub struct WidgetGeometrySnapshot {
1062 pub layout_bounds: Rect,
1063 pub input_bounds: Rect,
1064 pub paint_bounds: Rect,
1065}
1066
1067impl WidgetGeometrySnapshot {
1068 pub const fn new(layout_bounds: Rect, input_bounds: Rect, paint_bounds: Rect) -> Self {
1069 Self {
1070 layout_bounds,
1071 input_bounds,
1072 paint_bounds,
1073 }
1074 }
1075}
1076
1077#[derive(Debug, Clone, PartialEq)]
1078pub struct WidgetNodeSnapshot {
1079 pub id: WidgetId,
1080 pub widget_name: &'static str,
1081 pub parent: Option<WidgetId>,
1082 pub children: Vec<WidgetId>,
1083 pub measured_size: Size,
1084 pub geometry: WidgetGeometrySnapshot,
1085 pub local_bounds: Rect,
1086 pub presentation_transform: Transform,
1087 pub inverse_presentation_transform: Option<Transform>,
1088 pub bounds: Rect,
1090 pub paint_boundary: PaintBoundaryMode,
1091 pub stack_host: WidgetId,
1092 pub stack_surface: WidgetId,
1093 pub stack_surface_order: usize,
1094 pub transient_owner_surface: Option<WidgetId>,
1095 pub overlay_owner: Option<WidgetId>,
1097 pub is_overlay_owner: bool,
1098 pub is_stack_host: bool,
1099 pub is_stack_surface: bool,
1100 pub hit_test: bool,
1101 pub hit_test_self: bool,
1104 pub stack_order_policy: StackOrderPolicy,
1105 pub accepts_focus: bool,
1106 pub focused: bool,
1107 pub inert: bool,
1110}
1111
1112#[derive(Debug, Clone, PartialEq)]
1113pub struct StackHostSnapshot {
1114 pub host: WidgetId,
1115 pub order_policy: StackOrderPolicy,
1116 pub surfaces: Vec<WidgetId>,
1117}
1118
1119#[derive(Debug, Clone, PartialEq)]
1120pub struct WidgetGraphSnapshot {
1121 pub root: WidgetId,
1122 pub nodes: Vec<WidgetNodeSnapshot>,
1123 pub stack_hosts: Vec<StackHostSnapshot>,
1124}
1125
1126#[derive(Debug, Clone, Copy, PartialEq, Eq)]
1127pub enum EventRoutePhase {
1128 Capture,
1129 Target,
1130 Bubble,
1131}
1132
1133#[derive(Debug, Clone, Copy, PartialEq, Eq)]
1134pub struct EventRouteStep {
1135 pub widget_id: WidgetId,
1136 pub phase: EventRoutePhase,
1137 pub handled: bool,
1138}
1139
1140#[derive(Debug, Clone, PartialEq, Eq)]
1143pub struct EventRouteTraceSample {
1144 pub sequence: u64,
1145 pub event_kind: &'static str,
1146 pub target: WidgetId,
1147 pub path: Vec<WidgetId>,
1148 pub steps: Vec<EventRouteStep>,
1149 pub handled: bool,
1150}
1151
1152#[derive(Debug, Clone, Copy, PartialEq)]
1153pub struct TimerInspectorSnapshot {
1154 pub token: TimerToken,
1155 pub target: WidgetId,
1156 pub deadline: f64,
1157 pub delivering: bool,
1158}
1159
1160#[derive(Debug, Clone, Copy, PartialEq, Eq)]
1161pub struct AsyncTaskInspectorSnapshot {
1162 pub token: AsyncWakeToken,
1163 pub target: WidgetId,
1164 pub pending_wake: bool,
1165}
1166
1167#[derive(Debug, Clone, PartialEq, Default)]
1168pub struct SchedulerInspectorSnapshot {
1169 pub timers: Vec<TimerInspectorSnapshot>,
1170 pub async_tasks: Vec<AsyncTaskInspectorSnapshot>,
1171 pub requested_animation_frames: Vec<WidgetId>,
1172 pub delivering_animation_frames: Vec<WidgetId>,
1173 pub last_animation_frame_time: Option<f64>,
1174}
1175
1176#[derive(Debug, Clone, PartialEq, Default)]
1177pub struct InspectorHistorySnapshot {
1178 pub event_routes: Vec<EventRouteTraceSample>,
1179 pub reactive_invalidations: Vec<ReactiveInvalidationSample>,
1180 pub command_dispatches: Vec<CommandDispatchSample>,
1181 pub invalidations: Vec<InvalidationTraceSample>,
1182 pub widget_rebuilds: Vec<WidgetRebuildSample>,
1183}
1184
1185#[derive(Debug, Clone, PartialEq)]
1189pub struct WindowInspectorSnapshot {
1190 pub window_id: WindowId,
1191 pub title: String,
1192 pub tracing_enabled: bool,
1193 pub focus_state: FocusState,
1194 pub schedule: FrameSchedule,
1195 pub semantics: Vec<SemanticsNode>,
1196 pub widget_graph: WidgetGraphSnapshot,
1197 pub overlays: OverlayManagerSnapshot,
1198 pub scheduler: SchedulerInspectorSnapshot,
1199 pub widget_diagnostics: Vec<WidgetDiagnosticsSnapshot>,
1200 pub last_render_diagnostics: RenderDiagnostics,
1201 pub history: InspectorHistorySnapshot,
1202 pub scene: Option<SceneStatistics>,
1203}
1204
1205#[derive(Debug, Clone, Copy, PartialEq)]
1206struct ScheduledTimer {
1207 token: TimerToken,
1208 deadline: f64,
1209 target: WidgetId,
1210}
1211
1212#[derive(Debug, Clone, Copy, PartialEq)]
1213struct LayerTranslation {
1214 widget_id: WidgetId,
1215 delta: Vector,
1216}
1217
1218#[derive(Debug, Clone, PartialEq)]
1219struct LayerDescriptorRefresh {
1220 widget_id: WidgetId,
1221 descriptor: SceneLayerDescriptor,
1222}
1223
1224#[derive(Debug, Default)]
1225struct GraphChangeSet {
1226 output_widgets: Vec<WidgetId>,
1228 repaint_widgets: Vec<WidgetId>,
1229 transform_widgets: Vec<LayerTranslation>,
1230}
1231
1232const ANIMATION_FRAME_INTERVAL_SECONDS: f64 = 1.0 / 120.0;
1233
1234#[derive(Debug, Clone)]
1235struct ActiveDrag {
1236 session_id: DragSessionId,
1237 scope_id: DragScopeId,
1238 pointer_id: u64,
1239 source: WidgetId,
1240 start_position: Point,
1241 position: Point,
1242 payload: DragPayload,
1243 allowed_effects: DropEffects,
1244 preview_label: Option<Arc<str>>,
1245 modifiers: Modifiers,
1246 hover_path: Vec<WidgetId>,
1247 accepted_target: Option<WidgetId>,
1248 accepted_effect: DropEffect,
1249}
1250
1251impl ActiveDrag {
1252 fn from_request(request: BeginDragRequest) -> Self {
1253 Self {
1254 session_id: request.session_id,
1255 scope_id: request.scope_id,
1256 pointer_id: request.pointer_id,
1257 source: request.source,
1258 start_position: request.position,
1259 position: request.position,
1260 payload: request.payload,
1261 allowed_effects: request.allowed_effects,
1262 preview_label: request.preview_label.map(Arc::from),
1263 modifiers: Modifiers::NONE,
1264 hover_path: Vec::new(),
1265 accepted_target: None,
1266 accepted_effect: DropEffect::None,
1267 }
1268 }
1269
1270 fn event(
1271 &self,
1272 kind: DragEventKind,
1273 position: Point,
1274 target: Option<WidgetId>,
1275 accepted_effect: DropEffect,
1276 outcome: Option<DragOutcome>,
1277 ) -> Event {
1278 Event::Drag(DragEvent {
1279 kind,
1280 session_id: self.session_id,
1281 scope_id: self.scope_id,
1282 pointer_id: self.pointer_id,
1283 source: self.source,
1284 target,
1285 position,
1286 start_position: self.start_position,
1287 payload: self.payload.clone(),
1288 allowed_effect: self.allowed_effects.default_effect(),
1289 allowed_effects: self.allowed_effects,
1290 accepted_effect,
1291 preview_label: self.preview_label.clone(),
1292 outcome,
1293 modifiers: self.modifiers,
1294 })
1295 }
1296}
1297
1298#[derive(Debug, Default)]
1299struct RuntimeCursorState {
1300 state: WindowCursorState,
1301 grab_owner: Option<WidgetId>,
1302 visibility_owner: Option<WidgetId>,
1303}
1304
1305struct WindowState {
1306 id: WindowId,
1307 title: String,
1308 icon: Option<WindowIcon>,
1309 initial_size: Option<Size>,
1310 initial_position: Option<Point>,
1311 root: WidgetPod,
1312 measure_queries: measure_cache::SharedQueryCache,
1313 output_cache: output_cache::SharedOutputCache,
1314 graph: WidgetGraph,
1315 overlay_manager: overlay::OverlayManager,
1316 pending_overlay_focus: Option<FocusRequest>,
1317 focus: FocusState,
1318 focused_semantics: Option<WidgetId>,
1319 schedule: FrameSchedule,
1320 scale_factor: f32,
1321 raw_dpi: Option<f32>,
1322 safe_area: SafeAreaInsets,
1323 viewport_hint: Option<Size>,
1324 viewport: Option<Size>,
1325 last_frame: Option<SceneFrame>,
1326 last_paint_bounds_by_widget: FxHashMap<WidgetId, Rect>,
1327 last_image_registry_base: Option<Arc<ImageRegistry>>,
1329 retained_text_layout_count: usize,
1331 last_semantics: Vec<SemanticsNode>,
1332 pending_invalidations: Vec<InvalidationRequest>,
1333 pending_local_output: HashMap<(WidgetId, InvalidationKind), usize>,
1337 pending_reactive_diagnostics: Vec<ReactiveInvalidationSample>,
1338 reactive_hub: Arc<reactive::ReactiveInvalidationHub>,
1339 pointer_capture: HashMap<u64, WidgetId>,
1340 cursor: RuntimeCursorState,
1341 last_pointer_events: HashMap<u64, PointerEvent>,
1342 pointer_hover_paths: HashMap<u64, Vec<WidgetId>>,
1343 active_drag: Option<ActiveDrag>,
1344 drag_targets_stale: bool,
1347 scheduled_timers: Vec<ScheduledTimer>,
1348 delivering_timers: HashMap<TimerToken, WidgetId>,
1349 async_wake_targets: HashMap<AsyncWakeToken, WidgetId>,
1350 pending_async_wakeups: VecDeque<AsyncWakeToken>,
1351 requested_animation_frames: BTreeSet<WidgetId>,
1352 delivering_animation_frames: VecDeque<WidgetId>,
1353 active_motions: HashMap<(WidgetId, InvalidationKind), f64>,
1356 motion_ends: HashMap<(WidgetId, InvalidationKind), Vec<f64>>,
1359 frame_pacing: FramePacing,
1360 last_animation_frame_time: Option<f64>,
1361 next_animation_frame_index: u64,
1362 pending_animation_wake_count: usize,
1363 ime_composition_rect: Option<Rect>,
1364 touches_down: HashSet<u64>,
1366 held_ime_composition_rect: Option<Rect>,
1372 last_tick_time: f64,
1373 services: HostServices,
1374 command_sender: CommandSender,
1375 command_listeners: CommandListeners,
1376 pending_command_diagnostics: Vec<CommandDispatchSample>,
1377 pending_invalidation_diagnostics: Vec<InvalidationTraceSample>,
1378 inspector_tracing_enabled: bool,
1379 next_event_route_sequence: u64,
1380 event_route_history: VecDeque<EventRouteTraceSample>,
1381 reactive_invalidation_history: VecDeque<ReactiveInvalidationSample>,
1382 command_dispatch_history: VecDeque<CommandDispatchSample>,
1383 invalidation_history: VecDeque<InvalidationTraceSample>,
1384 widget_rebuild_history: VecDeque<WidgetRebuildSample>,
1385 last_render_diagnostics: RenderDiagnostics,
1386 painted_render_options: Option<WindowRenderOptions>,
1388 previous_graph: WidgetGraph,
1394 previous_graph_saved: bool,
1397}
1398
1399impl WindowState {
1400 #[allow(clippy::too_many_arguments)]
1401 fn new(
1402 id: WindowId,
1403 title: String,
1404 icon: Option<WindowIcon>,
1405 initial_size: Option<Size>,
1406 initial_position: Option<Point>,
1407 root: WidgetPod,
1408 command_listeners: CommandListeners,
1409 command_sender: CommandSender,
1410 ) -> Self {
1411 let focus = FocusState {
1412 focused_widget: None,
1413 window_focused: true,
1414 };
1415
1416 let reactive_hub = reactive::ReactiveInvalidationHub::new();
1417 reactive::register_window(id, &reactive_hub);
1418 Self {
1419 id,
1420 title,
1421 icon,
1422 initial_size,
1423 initial_position,
1424 graph: WidgetGraph::empty(root.id()),
1425 measure_queries: measure_cache::MeasureQueryCache::shared(),
1426 output_cache: output_cache::OutputCache::shared(),
1427 overlay_manager: overlay::OverlayManager::default(),
1428 pending_overlay_focus: None,
1429 root,
1430 focus,
1431 focused_semantics: None,
1432 schedule: FrameSchedule::bootstrap(),
1433 scale_factor: 1.0,
1434 raw_dpi: None,
1435 safe_area: SafeAreaInsets::ZERO,
1436 viewport_hint: None,
1437 viewport: None,
1438 last_frame: None,
1439 last_paint_bounds_by_widget: FxHashMap::default(),
1440 last_image_registry_base: None,
1441 retained_text_layout_count: 0,
1442 last_semantics: Vec::new(),
1443 pending_invalidations: Vec::new(),
1444 pending_local_output: HashMap::new(),
1445 pending_reactive_diagnostics: Vec::new(),
1446 reactive_hub,
1447 pointer_capture: HashMap::new(),
1448 cursor: RuntimeCursorState::default(),
1449 last_pointer_events: HashMap::new(),
1450 pointer_hover_paths: HashMap::new(),
1451 active_drag: None,
1452 drag_targets_stale: false,
1453 scheduled_timers: Vec::new(),
1454 delivering_timers: HashMap::new(),
1455 async_wake_targets: HashMap::new(),
1456 pending_async_wakeups: VecDeque::new(),
1457 requested_animation_frames: BTreeSet::new(),
1458 delivering_animation_frames: VecDeque::new(),
1459 active_motions: HashMap::new(),
1460 motion_ends: HashMap::new(),
1461 frame_pacing: FramePacing::Timer,
1462 last_animation_frame_time: None,
1463 next_animation_frame_index: 0,
1464 pending_animation_wake_count: 0,
1465 ime_composition_rect: None,
1466 touches_down: HashSet::new(),
1467 held_ime_composition_rect: None,
1468 last_tick_time: 0.0,
1469 services: HostServices::default(),
1470 command_sender,
1471 command_listeners,
1472 pending_command_diagnostics: Vec::new(),
1473 pending_invalidation_diagnostics: Vec::new(),
1474 inspector_tracing_enabled: false,
1475 next_event_route_sequence: 0,
1476 event_route_history: VecDeque::new(),
1477 reactive_invalidation_history: VecDeque::new(),
1478 command_dispatch_history: VecDeque::new(),
1479 invalidation_history: VecDeque::new(),
1480 widget_rebuild_history: VecDeque::new(),
1481 last_render_diagnostics: RenderDiagnostics::default(),
1482 painted_render_options: None,
1483 previous_graph: WidgetGraph::default(),
1484 previous_graph_saved: false,
1485 }
1486 }
1487
1488 fn repaint_for_render_options(&mut self) {
1492 let options = window_render_options(self.id);
1493 if options == self.painted_render_options {
1494 return;
1495 }
1496 self.painted_render_options = options;
1497 self.schedule.mark(InvalidationKind::Paint);
1498 self.pending_invalidations.push(InvalidationRequest::new(
1499 InvalidationTarget::Window(self.id),
1500 InvalidationKind::Paint,
1501 ));
1502 }
1503
1504 fn drain_reactive_invalidations(&mut self) {
1505 const MAX_REACTIVE_ROUNDS: usize = 8;
1506
1507 for _ in 0..MAX_REACTIVE_ROUNDS {
1508 let pending = self.reactive_hub.drain();
1509 if pending.is_empty() {
1510 break;
1511 }
1512
1513 let mut invalidations = Vec::new();
1514 let mut targets = BTreeSet::new();
1515 for (request, mut sample, local_output) in pending {
1516 let InvalidationTarget::Widget(widget_id) = request.target else {
1517 continue;
1518 };
1519 let delivered = self.graph.is_empty() || self.graph.contains(widget_id);
1520 sample.delivered = delivered;
1521 if delivered {
1522 push_trace(
1523 &mut self.pending_invalidation_diagnostics,
1524 InvalidationTraceSample {
1525 target: request.target,
1526 kind: request.kind,
1527 region: request.region,
1528 source: format!("reactive:{}", sample.source_name),
1529 reason: Some(format!("observable version {}", sample.version)),
1530 },
1531 );
1532 }
1533 self.pending_reactive_diagnostics.push(sample);
1534 if delivered {
1535 if local_output {
1536 *self
1537 .pending_local_output
1538 .entry((widget_id, request.kind))
1539 .or_default() += 1;
1540 }
1541 targets.insert(widget_id);
1542 invalidations.push(request);
1543 }
1544 }
1545
1546 for target in targets {
1547 let command = command::queued_command(
1548 CommandTarget::Widget {
1549 window_id: self.id,
1550 widget_id: target,
1551 },
1552 CommandDelivery::Directed,
1553 REACTIVE_CHANGED,
1554 (),
1555 );
1556 let Some(dispatch) = self.dispatch_direct_command(target, &command) else {
1557 continue;
1558 };
1559 if dispatch.handled {
1560 self.pending_local_output.retain(|(id, _), _| *id != target);
1563 }
1564 let focus_request = dispatch.focus_request;
1565 let mut effects = EventEffects::default();
1566 effects.extend(dispatch);
1567 self.apply_event_effects(effects, &mut invalidations);
1568 if let Some(request) = focus_request {
1569 let focus_effects = self.apply_focus_request(request);
1570 self.apply_event_effects(focus_effects, &mut invalidations);
1571 }
1572 }
1573
1574 self.schedule.extend(&invalidations);
1575 self.pending_invalidations.extend(invalidations);
1576 }
1577 }
1578
1579 fn needs_render(&self) -> bool {
1580 self.last_frame.is_none()
1581 || self.schedule.needs_render()
1582 || self.reactive_hub.has_pending()
1583 || window_render_options(self.id) != self.painted_render_options
1584 }
1585
1586 fn handle_event(
1587 &mut self,
1588 event: Event,
1589 text_system: Arc<TextSystem>,
1590 font_registry: Arc<FontRegistry>,
1591 image_registry: Arc<ImageRegistry>,
1592 ) -> bool {
1593 if matches!(event, Event::Window(WindowEvent::RedrawRequested)) {
1594 diagnostics::begin_widget_timing_collection();
1595 sui_text::begin_text_timing_collection();
1596 }
1597 if matches!(event, Event::Wake(WakeEvent::AnimationFrame { .. })) {
1598 self.pending_animation_wake_count = self.pending_animation_wake_count.saturating_add(1);
1599 }
1600 if let Event::Pointer(pointer) = &event {
1601 if pointer.pointer_kind == PointerKind::Touch && pointer.kind == PointerEventKind::Down
1602 {
1603 if self.touches_down.is_empty() {
1604 self.held_ime_composition_rect = self.ime_composition_rect;
1605 }
1606 self.touches_down.insert(pointer.pointer_id);
1607 }
1608 self.last_pointer_events
1609 .insert(pointer.pointer_id, pointer.clone());
1610 }
1611
1612 self.preprocess_window_event(&event);
1613 self.ensure_graph_for_event(&event, text_system, font_registry, image_registry);
1614
1615 let mut invalidations = Vec::new();
1616 self.apply_pending_overlay_focus(&mut invalidations);
1617
1618 let captured_target = match &event {
1619 Event::Pointer(pointer) => self.pointer_capture.get(&pointer.pointer_id).copied(),
1620 _ => None,
1621 };
1622
1623 let pointer_hit_target = match &event {
1624 Event::Pointer(pointer) => self.pointer_hit_target(pointer.position),
1625 _ => None,
1626 };
1627 let mut hit_target = match &event {
1628 Event::Pointer(_) if captured_target.is_some() => None,
1629 Event::Pointer(_) => pointer_hit_target,
1630 _ => None,
1631 };
1632
1633 if matches!(event, Event::Window(WindowEvent::Focused(false))) {
1634 self.cancel_all_pointer_captures(&mut invalidations);
1635 self.pointer_capture.clear();
1636 self.last_pointer_events.clear();
1637 self.touches_down.clear();
1638 self.release_ime_hold();
1639 let position = self.active_drag.as_ref().map(|drag| drag.position);
1640 if let Some(position) = position {
1641 let effects = self.finish_active_drag(position, true);
1642 self.apply_event_effects(effects, &mut invalidations);
1643 }
1644 self.reset_cursor_state();
1645 }
1646 if self.drag_targets_stale {
1647 self.drag_targets_stale = false;
1651 if !matches!(
1653 &event,
1654 Event::Pointer(pointer)
1655 if self.is_drag_pointer(pointer)
1656 && matches!(pointer.kind, PointerEventKind::Move | PointerEventKind::Up)
1657 ) {
1658 let effects = self.refresh_active_drag();
1659 self.apply_event_effects(effects, &mut invalidations);
1660 }
1661 }
1662 if let Event::Keyboard(key) = &event
1663 && self.active_drag.is_some()
1664 && self.handle_drag_key_event(key, &mut invalidations)
1665 {
1666 self.finish_event(&event);
1667 self.record_event_invalidations(&invalidations, &event);
1668 self.schedule.extend(&invalidations);
1669 self.pending_invalidations.extend(invalidations);
1670 return true;
1671 }
1672 let mut skip_primary_route = false;
1673 if let Event::Pointer(pointer) = &event {
1674 let hover_route = self.update_pointer_hover_path(pointer, hit_target);
1675 self.apply_event_effects(hover_route.effects, &mut invalidations);
1676
1677 if let Some(request) = hover_route.focus_request {
1678 let focus_effects = self.apply_focus_request(request);
1679 self.apply_event_effects(focus_effects, &mut invalidations);
1680 }
1681
1682 skip_primary_route = hover_route.skip_primary_route;
1683 }
1684
1685 if skip_primary_route {
1686 self.finish_event(&event);
1687 self.record_event_invalidations(&invalidations, &event);
1688 self.schedule.extend(&invalidations);
1689 self.pending_invalidations.extend(invalidations);
1690 return false;
1691 }
1692
1693 if matches!(
1694 &event,
1695 Event::Keyboard(key)
1696 if key.state == KeyState::Pressed
1697 && key.key == "BrowserBack"
1698 && !key.repeat
1699 && !key.is_composing
1700 ) && self.ime_composition_rect.is_some()
1701 && self.focus.focused_widget.is_some()
1702 {
1703 self.ime_composition_rect = None;
1708 self.held_ime_composition_rect = None;
1709 let effects = self.apply_focus_request_unconstrained(FocusRequest::Clear);
1710 self.apply_event_effects(effects, &mut invalidations);
1711 self.finish_event(&event);
1712 self.record_event_invalidations(&invalidations, &event);
1713 self.schedule.extend(&invalidations);
1714 self.pending_invalidations.extend(invalidations);
1715 return true;
1716 }
1717
1718 if matches!(
1719 &event,
1720 Event::Keyboard(key)
1721 if key.state == KeyState::Pressed
1722 && matches!(key.key.as_str(), "Escape" | "BrowserBack")
1723 && !key.repeat
1724 && !key.is_composing
1725 ) && self.dispatch_overlay_dismissal(
1726 OverlayDismissReason::Escape,
1727 None,
1728 &mut invalidations,
1729 ) {
1730 self.finish_event(&event);
1731 self.record_event_invalidations(&invalidations, &event);
1732 self.schedule.extend(&invalidations);
1733 self.pending_invalidations.extend(invalidations);
1734 return true;
1735 }
1736
1737 if let Event::Pointer(pointer) = &event
1738 && pointer.kind == PointerEventKind::Down
1739 && pointer.button == Some(PointerButton::Primary)
1740 && let Some(entry) = self
1741 .overlay_manager
1742 .topmost_dismissible(OverlayDismissReason::OutsidePointer)
1743 .cloned()
1744 && !hit_target.is_some_and(|target| self.target_is_in_overlay(entry.owner, target))
1745 {
1746 self.dispatch_overlay_dismissal(
1747 OverlayDismissReason::OutsidePointer,
1748 Some(pointer.position),
1749 &mut invalidations,
1750 );
1751 }
1752
1753 if let Some(modal) = self.overlay_manager.active_modal()
1754 && hit_target.is_some_and(|target| !self.target_is_in_overlay(modal, target))
1755 {
1756 hit_target = Some(modal);
1757 }
1758
1759 let target = self.resolve_event_target(&event, hit_target);
1760
1761 let route = self.route_event(target, &event);
1762 let handled = route.handled;
1763
1764 let focus_request = route
1765 .focus_request
1766 .or_else(|| self.default_focus_request(&event, hit_target, &route.path));
1767 self.apply_event_effects(route.effects, &mut invalidations);
1768
1769 if let Some(request) = focus_request {
1770 let focus_effects = self.apply_focus_request(request);
1771 self.apply_event_effects(focus_effects, &mut invalidations);
1772 }
1773
1774 if let Event::Pointer(pointer) = &event {
1775 let drag_effects = self.handle_drag_pointer_event(pointer, pointer_hit_target);
1776 self.apply_event_effects(drag_effects, &mut invalidations);
1777 }
1778
1779 self.finish_event(&event);
1780 self.record_event_invalidations(&invalidations, &event);
1781 self.schedule.extend(&invalidations);
1782 self.pending_invalidations.extend(invalidations);
1783 handled
1784 }
1785
1786 fn record_command_dispatch(&mut self, sample: CommandDispatchSample) {
1789 command_history::record_window_command_dispatch(self.id, sample.clone());
1790 push_trace(&mut self.pending_command_diagnostics, sample);
1791 }
1792
1793 fn record_event_invalidations(&mut self, invalidations: &[InvalidationRequest], event: &Event) {
1794 let source = event_trace_source(event);
1795 extend_traces(
1796 &mut self.pending_invalidation_diagnostics,
1797 invalidations.iter().map(|request| InvalidationTraceSample {
1798 target: request.target,
1799 kind: request.kind,
1800 region: request.region,
1801 source: source.clone(),
1802 reason: None,
1803 }),
1804 );
1805 }
1806
1807 fn target_is_in_overlay(&self, owner: WidgetId, target: WidgetId) -> bool {
1808 target == owner || self.graph.is_ancestor_of(owner, target)
1809 }
1810
1811 fn dispatch_overlay_dismissal(
1812 &mut self,
1813 reason: OverlayDismissReason,
1814 pointer_position: Option<Point>,
1815 invalidations: &mut Vec<InvalidationRequest>,
1816 ) -> bool {
1817 let Some(entry) = self.overlay_manager.topmost_dismissible(reason).cloned() else {
1818 return false;
1819 };
1820 let mut request = OverlayDismissRequest::new(reason);
1821 request.pointer_position = pointer_position;
1822 let queued = command::queued_command(
1823 CommandTarget::Widget {
1824 window_id: self.id,
1825 widget_id: entry.owner,
1826 },
1827 CommandDelivery::Directed,
1828 OVERLAY_DISMISS_REQUEST,
1829 request,
1830 );
1831 let Some(dispatch) = self.dispatch_direct_command(entry.owner, &queued) else {
1832 return false;
1833 };
1834 let handled = dispatch.handled;
1835 let focus_request = dispatch.focus_request;
1836 let mut effects = EventEffects::default();
1837 effects.extend(dispatch);
1838 self.apply_event_effects(effects, invalidations);
1839 if let Some(request) = focus_request {
1840 let effects = self.apply_focus_request(request);
1841 self.apply_event_effects(effects, invalidations);
1842 }
1843 if handled {
1844 self.overlay_manager
1845 .trace_dismissal(entry.owner, entry.options.kind, reason);
1846 }
1847 handled
1848 }
1849
1850 fn handle_semantics_action(
1851 &mut self,
1852 target: WidgetId,
1853 action: SemanticsActionRequest,
1854 text_system: Arc<TextSystem>,
1855 font_registry: Arc<FontRegistry>,
1856 image_registry: Arc<ImageRegistry>,
1857 ) -> bool {
1858 let Some(node) = self
1859 .last_semantics
1860 .iter()
1861 .find(|node| node.id == target)
1862 .cloned()
1863 else {
1864 return false;
1865 };
1866
1867 if node.state.hidden
1868 || node.state.disabled
1869 || !node.actions.contains(&action.advertised_action())
1870 {
1871 return false;
1872 }
1873
1874 if matches!(
1875 (&action, node.state.expanded),
1876 (SemanticsActionRequest::Expand, Some(true))
1877 | (SemanticsActionRequest::Collapse, Some(false))
1878 ) {
1879 return true;
1880 }
1881
1882 let event = Event::Semantics(SemanticsEvent::new(target, action.clone()));
1883 self.ensure_graph_for_event(
1884 &event,
1885 Arc::clone(&text_system),
1886 Arc::clone(&font_registry),
1887 Arc::clone(&image_registry),
1888 );
1889
1890 let route_target = self.semantics_route_target(target);
1891 let route = self.route_event(route_target, &event);
1892 let handled = route.handled;
1893 let semantics_was_focused = self.focused_semantics == Some(target);
1894 let mut focus_request = route.focus_request;
1895 let widget_requested_focus = matches!(focus_request, Some(FocusRequest::Focus(_)));
1896 let mut focus_succeeded = false;
1897 let mut invalidations = Vec::new();
1898 self.apply_event_effects(route.effects, &mut invalidations);
1899
1900 match action {
1901 SemanticsActionRequest::Focus => {
1902 let runtime_focus_request = focus_request
1903 .is_none()
1904 .then(|| self.focus_request_for(route_target))
1905 .flatten();
1906 focus_succeeded =
1907 handled || widget_requested_focus || runtime_focus_request.is_some();
1908 focus_request = focus_request.or(runtime_focus_request);
1909 }
1910 SemanticsActionRequest::Blur if semantics_was_focused => {
1911 focus_request = Some(FocusRequest::Clear);
1912 }
1913 _ => {}
1914 }
1915
1916 if let Some(request) = focus_request {
1917 let focus_effects = self.apply_focus_request(request);
1918 self.apply_event_effects(focus_effects, &mut invalidations);
1919 }
1920
1921 match action {
1922 SemanticsActionRequest::Focus if focus_succeeded => {
1923 self.focused_semantics = Some(target);
1924 self.schedule.mark(InvalidationKind::Semantics);
1925 }
1926 SemanticsActionRequest::Blur if semantics_was_focused => {
1927 self.focused_semantics = None;
1928 self.schedule.mark(InvalidationKind::Semantics);
1929 }
1930 _ => {}
1931 }
1932
1933 self.schedule.extend(&invalidations);
1934 self.pending_invalidations.extend(invalidations);
1935
1936 let pointer_fallback = matches!(
1937 action,
1938 SemanticsActionRequest::Activate
1939 | SemanticsActionRequest::Expand
1940 | SemanticsActionRequest::Collapse
1941 );
1942 if pointer_fallback && !handled && !node.bounds.is_empty() {
1943 self.dispatch_semantics_pointer_activation(
1944 node.bounds,
1945 text_system,
1946 font_registry,
1947 image_registry,
1948 );
1949 return true;
1950 }
1951
1952 handled
1953 || matches!(action, SemanticsActionRequest::Focus) && focus_succeeded
1954 || matches!(action, SemanticsActionRequest::Blur) && semantics_was_focused
1955 }
1956
1957 fn semantics_route_target(&self, target: WidgetId) -> WidgetId {
1958 let mut current = Some(target);
1959 let mut visited = HashSet::new();
1960
1961 while let Some(candidate) = current {
1962 if !visited.insert(candidate) {
1963 break;
1964 }
1965 if self.graph.contains(candidate) {
1966 return candidate;
1967 }
1968 current = self
1969 .last_semantics
1970 .iter()
1971 .find(|node| node.id == candidate)
1972 .and_then(|node| node.parent);
1973 }
1974
1975 self.root.id()
1976 }
1977
1978 fn focus_request_for(&self, target: WidgetId) -> Option<FocusRequest> {
1979 self.graph.path_to(target).and_then(|path| {
1980 path.into_iter()
1981 .rev()
1982 .find(|widget_id| {
1983 self.graph
1984 .node(*widget_id)
1985 .is_some_and(|node| node.accepts_focus)
1986 })
1987 .map(FocusRequest::Focus)
1988 })
1989 }
1990
1991 fn dispatch_semantics_pointer_activation(
1992 &mut self,
1993 bounds: Rect,
1994 text_system: Arc<TextSystem>,
1995 font_registry: Arc<FontRegistry>,
1996 image_registry: Arc<ImageRegistry>,
1997 ) {
1998 let position = Point::new(
1999 bounds.x() + bounds.width() * 0.5,
2000 bounds.y() + bounds.height() * 0.5,
2001 );
2002
2003 let mut down = PointerEvent::new(PointerEventKind::Down, position);
2004 down.button = Some(PointerButton::Primary);
2005 down.buttons.insert(PointerButton::Primary);
2006 self.handle_event(
2007 Event::Pointer(down),
2008 Arc::clone(&text_system),
2009 Arc::clone(&font_registry),
2010 Arc::clone(&image_registry),
2011 );
2012
2013 let mut up = PointerEvent::new(PointerEventKind::Up, position);
2014 up.button = Some(PointerButton::Primary);
2015 self.handle_event(
2016 Event::Pointer(up),
2017 text_system,
2018 font_registry,
2019 image_registry,
2020 );
2021 }
2022
2023 fn update_pointer_hover_path(
2024 &mut self,
2025 pointer: &PointerEvent,
2026 hit_target: Option<WidgetId>,
2027 ) -> HoverTransitionResult {
2028 let skip_primary_route = matches!(
2029 pointer.kind,
2030 PointerEventKind::Enter | PointerEventKind::Leave
2031 );
2032
2033 let next_path = match pointer.kind {
2034 PointerEventKind::Move | PointerEventKind::Enter
2035 if pointer.buttons.is_empty()
2036 && !self.pointer_capture.contains_key(&pointer.pointer_id) =>
2037 {
2038 self.hover_transition_path(hit_target)
2039 }
2040 PointerEventKind::Leave | PointerEventKind::Cancel => Vec::new(),
2041 _ => {
2042 return HoverTransitionResult {
2043 skip_primary_route,
2044 ..HoverTransitionResult::default()
2045 };
2046 }
2047 };
2048
2049 let previous_path = self
2050 .pointer_hover_paths
2051 .remove(&pointer.pointer_id)
2052 .unwrap_or_default();
2053 if previous_path == next_path {
2054 if !next_path.is_empty() {
2055 self.pointer_hover_paths
2056 .insert(pointer.pointer_id, next_path);
2057 }
2058 return HoverTransitionResult {
2059 skip_primary_route,
2060 ..HoverTransitionResult::default()
2061 };
2062 }
2063
2064 let shared_prefix_len = previous_path
2065 .iter()
2066 .zip(next_path.iter())
2067 .take_while(|(left, right)| left == right)
2068 .count();
2069
2070 let mut result = HoverTransitionResult {
2071 skip_primary_route,
2072 ..HoverTransitionResult::default()
2073 };
2074
2075 let mut leave_pointer = pointer.clone();
2076 leave_pointer.kind = PointerEventKind::Leave;
2077 let leave_event = Event::Pointer(leave_pointer);
2078 for widget_id in previous_path[shared_prefix_len..].iter().rev().copied() {
2079 let dispatch = self.dispatch_direct_event(widget_id, &leave_event);
2080 let dispatch_focus_request = dispatch.focus_request;
2081 result.effects.extend(dispatch);
2082 if dispatch_focus_request.is_some() {
2083 result.focus_request = dispatch_focus_request;
2084 }
2085 }
2086
2087 let mut enter_pointer = pointer.clone();
2088 enter_pointer.kind = PointerEventKind::Enter;
2089 let enter_event = Event::Pointer(enter_pointer);
2090 for widget_id in next_path[shared_prefix_len..].iter().copied() {
2091 let dispatch = self.dispatch_direct_event(widget_id, &enter_event);
2092 let dispatch_focus_request = dispatch.focus_request;
2093 result.effects.extend(dispatch);
2094 if dispatch_focus_request.is_some() {
2095 result.focus_request = dispatch_focus_request;
2096 }
2097 }
2098
2099 if !next_path.is_empty() {
2100 self.pointer_hover_paths
2101 .insert(pointer.pointer_id, next_path);
2102 }
2103
2104 result
2105 }
2106
2107 fn hover_transition_path(&self, hit_target: Option<WidgetId>) -> Vec<WidgetId> {
2108 hit_target
2109 .and_then(|target| self.graph.path_to(target))
2110 .map(|path| path.into_iter().skip(1).collect())
2111 .unwrap_or_default()
2112 }
2113
2114 fn dispatch_direct_event(&mut self, target: WidgetId, event: &Event) -> widget::EventDispatch {
2115 let path = self.graph.path_to(target);
2116 let dpi_info = self.current_dpi_info();
2117 self.root
2118 .dispatch_event_for_path(
2119 path.as_deref().unwrap_or(&[self.root.id()]),
2120 self.id,
2121 dpi_info,
2122 self.last_tick_time,
2123 EventPhase::Target,
2124 self.focus.focused_widget,
2125 &self.services,
2126 &self.command_sender,
2127 event,
2128 )
2129 .or_else(|| {
2130 self.root.dispatch_event_for(
2131 target,
2132 self.id,
2133 dpi_info,
2134 self.last_tick_time,
2135 EventPhase::Target,
2136 self.focus.focused_widget,
2137 &self.services,
2138 &self.command_sender,
2139 event,
2140 )
2141 })
2142 .unwrap_or_else(empty_dispatch)
2143 }
2144
2145 fn dispatch_direct_command(
2146 &mut self,
2147 target: WidgetId,
2148 command: &QueuedCommand,
2149 ) -> Option<widget::EventDispatch> {
2150 let path = if target == self.root.id() {
2151 vec![target]
2152 } else {
2153 self.graph.path_to(target)?
2154 };
2155 let dpi_info = self.current_dpi_info();
2156 let command = Command::new(command);
2157 self.root
2158 .dispatch_command_for_path(
2159 &path,
2160 self.id,
2161 dpi_info,
2162 self.last_tick_time,
2163 self.focus.focused_widget,
2164 &self.services,
2165 &self.command_sender,
2166 &command,
2167 )
2168 .or_else(|| {
2169 self.root.dispatch_command_for(
2170 target,
2171 self.id,
2172 dpi_info,
2173 self.last_tick_time,
2174 self.focus.focused_widget,
2175 &self.services,
2176 &self.command_sender,
2177 &command,
2178 )
2179 })
2180 }
2181
2182 fn record_command_invalidations(
2183 &mut self,
2184 invalidations: &[InvalidationRequest],
2185 source: &str,
2186 reason: Option<&str>,
2187 ) {
2188 extend_traces(
2189 &mut self.pending_invalidation_diagnostics,
2190 invalidations.iter().map(|request| InvalidationTraceSample {
2191 target: request.target,
2192 kind: request.kind,
2193 region: request.region,
2194 source: format!("command:{source}"),
2195 reason: reason.map(str::to_string),
2196 }),
2197 );
2198 }
2199
2200 fn pointer_hit_target(&mut self, point: Point) -> Option<WidgetId> {
2201 let floating_hit = self.floating_layer_hit_test(point);
2202 let focused_floating_hit = if floating_hit.is_none() {
2203 self.focused_floating_layer_hit_test(point)
2204 } else {
2205 None
2206 };
2207 floating_hit
2208 .or(focused_floating_hit)
2209 .or_else(|| self.graph.hit_test(point))
2210 }
2211
2212 fn floating_layer_hit_test(&mut self, point: Point) -> Option<WidgetId> {
2213 let effect_hit = {
2214 let scene = self.last_frame.as_ref().map(|frame| &frame.scene)?;
2215 scene_hit_test_for_phase(
2216 scene,
2217 point,
2218 HitTestCompositionPhase::Effect,
2219 HitTestCompositionPhase::Normal,
2220 )
2221 };
2222 if let Some(widget_id) = effect_hit
2223 && self
2224 .current_widget_matches_hit_test_phase(widget_id, HitTestCompositionPhase::Effect)
2225 {
2226 return self
2227 .graph
2228 .hit_test_within(widget_id, point)
2229 .or(Some(widget_id));
2230 }
2231
2232 let overlay_hit = {
2233 let scene = self.last_frame.as_ref().map(|frame| &frame.scene)?;
2234 scene_hit_test_for_phase(
2235 scene,
2236 point,
2237 HitTestCompositionPhase::Overlay,
2238 HitTestCompositionPhase::Normal,
2239 )
2240 };
2241 overlay_hit.and_then(|widget_id| {
2242 self.current_widget_matches_hit_test_phase(widget_id, HitTestCompositionPhase::Overlay)
2243 .then(|| {
2244 self.graph
2245 .hit_test_within(widget_id, point)
2246 .unwrap_or(widget_id)
2247 })
2248 })
2249 }
2250
2251 fn focused_floating_layer_hit_test(&mut self, point: Point) -> Option<WidgetId> {
2252 let focused = self.focus.focused_widget?;
2253 if !self.current_widget_matches_hit_test_phase(focused, HitTestCompositionPhase::Overlay)
2254 && !self.current_widget_matches_hit_test_phase(focused, HitTestCompositionPhase::Effect)
2255 {
2256 return None;
2257 }
2258
2259 let scene = self.last_frame.as_ref().map(|frame| &frame.scene)?;
2260 let descriptor = collect_scene_layers(scene).get(&focused)?.clone();
2261 (descriptor.hit_test && descriptor.paint_bounds.contains(point)).then_some(focused)
2262 }
2263
2264 fn current_widget_matches_hit_test_phase(
2265 &mut self,
2266 widget_id: WidgetId,
2267 target_phase: HitTestCompositionPhase,
2268 ) -> bool {
2269 if !self.graph.node(widget_id).is_some_and(|node| node.hit_test) {
2270 return false;
2271 }
2272 let Some(composition_mode) = self.current_widget_composition_mode(widget_id) else {
2273 return false;
2274 };
2275
2276 next_hit_test_phase(HitTestCompositionPhase::Normal, composition_mode) == target_phase
2277 }
2278
2279 fn current_widget_composition_mode(
2280 &mut self,
2281 widget_id: WidgetId,
2282 ) -> Option<LayerCompositionMode> {
2283 self.root.layer_composition_mode_for(widget_id)
2284 }
2285
2286 fn wants_animation_frame(&self) -> bool {
2288 !self.requested_animation_frames.is_empty()
2289 || !self.active_motions.is_empty()
2290 || !self.motion_ends.is_empty()
2291 }
2292
2293 fn animation_frame_deadline(&self) -> Option<f64> {
2296 (self.frame_pacing == FramePacing::Timer && self.wants_animation_frame()).then_some(
2297 self.last_animation_frame_time
2298 .map_or(self.last_tick_time, |last| {
2299 last + ANIMATION_FRAME_INTERVAL_SECONDS
2300 }),
2301 )
2302 }
2303
2304 fn frame_time(&self) -> f64 {
2307 self.last_animation_frame_time
2308 .map_or(self.last_tick_time, |frame| frame.max(self.last_tick_time))
2309 }
2310
2311 fn start_animation_frame(&mut self, frame_time: f64) -> Vec<Event> {
2314 let frame_time = self
2315 .last_animation_frame_time
2316 .map_or(frame_time, |last| frame_time.max(last));
2317 let delta = self
2318 .last_animation_frame_time
2319 .map(|last| frame_time - last)
2320 .unwrap_or(0.0);
2321 let frame_index = self.next_animation_frame_index;
2322 self.next_animation_frame_index = self.next_animation_frame_index.saturating_add(1);
2323
2324 let requested = std::mem::take(&mut self.requested_animation_frames);
2325 self.delivering_animation_frames
2326 .extend(requested.iter().copied());
2327 let events = requested
2328 .iter()
2329 .map(|_| {
2330 Event::Wake(WakeEvent::AnimationFrame {
2331 time: frame_time,
2332 delta,
2333 frame_index,
2334 })
2335 })
2336 .collect();
2337 self.last_animation_frame_time = Some(frame_time);
2338 self.tick_motions(frame_time);
2339 if self.delivering_animation_frames.is_empty() && !self.wants_animation_frame() {
2340 self.last_animation_frame_time = None;
2342 }
2343 events
2344 }
2345
2346 fn tick_motions(&mut self, frame_time: f64) {
2349 if self.active_motions.is_empty() && self.motion_ends.is_empty() {
2350 return;
2351 }
2352 let mut invalidations = Vec::with_capacity(self.active_motions.len());
2353 let graph = &self.graph;
2357 self.active_motions.retain(|&(widget_id, kind), until| {
2358 if graph.contains(widget_id) {
2359 invalidations.push(InvalidationRequest::new(
2360 InvalidationTarget::Widget(widget_id),
2361 kind,
2362 ));
2363 }
2364 frame_time < *until
2365 });
2366 self.motion_ends.retain(|&(widget_id, kind), ends| {
2367 if !graph.contains(widget_id) {
2368 return true;
2369 }
2370 let pending = ends.len();
2371 ends.retain(|end| frame_time < *end);
2372 if ends.len() != pending {
2373 invalidations.push(InvalidationRequest::new(
2374 InvalidationTarget::Widget(widget_id),
2375 kind,
2376 ));
2377 }
2378 !ends.is_empty()
2379 });
2380 for request in &invalidations {
2381 if let InvalidationTarget::Widget(widget_id) = request.target {
2382 *self
2385 .pending_local_output
2386 .entry((widget_id, request.kind))
2387 .or_default() += 1;
2388 }
2389 }
2390 self.schedule.extend(&invalidations);
2391 self.pending_invalidations.extend(invalidations);
2392 }
2393
2394 fn begin_animation_frame(&mut self, frame_time: f64) -> Vec<Event> {
2396 if !self.wants_animation_frame() {
2397 return Vec::new();
2398 }
2399 self.start_animation_frame(frame_time)
2400 }
2401
2402 fn next_wakeup_time(&self) -> Option<f64> {
2403 let mut next = self
2404 .scheduled_timers
2405 .iter()
2406 .map(|timer| timer.deadline)
2407 .min_by(|left, right| left.total_cmp(right));
2408
2409 if !self.pending_async_wakeups.is_empty() {
2410 next = Some(next.map_or(self.last_tick_time, |deadline| {
2411 deadline.min(self.last_tick_time)
2412 }));
2413 }
2414
2415 if let Some(animation_deadline) = self.animation_frame_deadline() {
2416 next = Some(next.map_or(animation_deadline, |deadline| {
2417 deadline.min(animation_deadline)
2418 }));
2419 }
2420
2421 next
2422 }
2423
2424 fn active_animated_widget_count(&self) -> usize {
2425 self.requested_animation_frames
2426 .iter()
2427 .copied()
2428 .chain(self.delivering_animation_frames.iter().copied())
2429 .chain(self.active_motions.keys().map(|(widget_id, _)| *widget_id))
2430 .chain(self.motion_ends.keys().map(|(widget_id, _)| *widget_id))
2431 .collect::<BTreeSet<_>>()
2432 .len()
2433 }
2434
2435 fn animation_frame_is_transform_only(
2436 &self,
2437 repainted: bool,
2438 layer_updates: &[SceneLayerUpdate],
2439 ) -> bool {
2440 !repainted
2441 && !layer_updates.is_empty()
2442 && layer_updates.iter().all(|update| {
2443 matches!(
2444 update.kind,
2445 SceneLayerUpdateKind::Transform
2446 | SceneLayerUpdateKind::Effect
2447 | SceneLayerUpdateKind::Visibility
2448 )
2449 })
2450 }
2451
2452 fn drain_ready_events(&mut self) -> Vec<Event> {
2453 let now = self.last_tick_time;
2454 let mut ready = Vec::new();
2455 let mut pending_timers = Vec::with_capacity(self.scheduled_timers.len());
2456
2457 for timer in self.scheduled_timers.drain(..) {
2458 if timer.deadline <= now {
2459 self.delivering_timers.insert(timer.token, timer.target);
2460 ready.push(Event::Wake(WakeEvent::Timer {
2461 token: timer.token,
2462 time: now,
2463 deadline: timer.deadline,
2464 }));
2465 } else {
2466 pending_timers.push(timer);
2467 }
2468 }
2469 self.scheduled_timers = pending_timers;
2470
2471 while let Some(token) = self.pending_async_wakeups.pop_front() {
2472 if self.async_wake_targets.contains_key(&token) {
2473 ready.push(Event::Wake(WakeEvent::Async { token, time: now }));
2474 }
2475 }
2476
2477 if self
2478 .animation_frame_deadline()
2479 .is_some_and(|deadline| deadline <= now)
2480 {
2481 ready.extend(self.start_animation_frame(now));
2482 } else if self.delivering_animation_frames.is_empty() && !self.wants_animation_frame() {
2483 self.last_animation_frame_time = None;
2484 }
2485
2486 ready
2487 }
2488
2489 fn wake_async(&mut self, token: AsyncWakeToken) -> bool {
2490 if !self.async_wake_targets.contains_key(&token) {
2491 return false;
2492 }
2493
2494 self.pending_async_wakeups.push_back(token);
2495 true
2496 }
2497
2498 fn invalidate_layout_for_viewport_change(&mut self) {
2505 self.schedule.mark(InvalidationKind::Measure);
2506 self.pending_invalidations.push(InvalidationRequest::new(
2507 InvalidationTarget::Window(self.id),
2508 InvalidationKind::Measure,
2509 ));
2510 }
2511
2512 fn preprocess_window_event(&mut self, event: &Event) {
2513 let Event::Window(window_event) = event else {
2514 return;
2515 };
2516
2517 match window_event {
2518 WindowEvent::Resized(size) => {
2519 self.viewport_hint = Some(*size);
2520 self.invalidate_layout_for_viewport_change();
2521 }
2522 WindowEvent::ScaleFactorChanged {
2523 scale_factor,
2524 raw_dpi,
2525 suggested_size,
2526 } => {
2527 self.scale_factor = *scale_factor as f32;
2528 self.raw_dpi = *raw_dpi;
2529 if let Some(size) = suggested_size {
2530 self.viewport_hint = Some(*size);
2531 }
2532 self.invalidate_layout_for_viewport_change();
2533 }
2534 WindowEvent::SafeAreaChanged(safe_area) => {
2535 let safe_area = safe_area.normalized();
2536 if self.safe_area != safe_area {
2537 self.safe_area = safe_area;
2538 self.invalidate_layout_for_viewport_change();
2539 }
2540 }
2541 WindowEvent::Focused(focused) => {
2542 self.focus.window_focused = *focused;
2543 }
2544 WindowEvent::RedrawRequested => {
2545 self.schedule.mark(InvalidationKind::Paint);
2546 }
2547 WindowEvent::CloseRequested
2548 | WindowEvent::Moved(_)
2549 | WindowEvent::Occluded(_)
2550 | WindowEvent::ExternalFileHovered(_)
2551 | WindowEvent::ExternalFileHoverCancelled
2552 | WindowEvent::ExternalFileDropped(_) => {}
2553 }
2554 }
2555
2556 fn ensure_graph_for_event(
2557 &mut self,
2558 event: &Event,
2559 text_system: Arc<TextSystem>,
2560 font_registry: Arc<FontRegistry>,
2561 image_registry: Arc<ImageRegistry>,
2562 ) {
2563 if self.schedule.measure || self.schedule.arrange || self.viewport.is_none() {
2564 let scope_source = self.pending_invalidations.clone();
2565 let invalidations = self.run_measure_arrange_pass(
2566 &scope_source,
2567 text_system,
2568 font_registry,
2569 image_registry,
2570 );
2571 self.schedule.extend(&invalidations);
2572 self.pending_invalidations.extend(invalidations);
2573 return;
2574 }
2575
2576 if self.schedule.hit_test || self.graph.is_empty() {
2577 self.refresh_graph();
2578 }
2579
2580 if matches!(event, Event::Keyboard(_) | Event::Ime(_))
2581 && self.focus.focused_widget.is_some()
2582 && !self
2583 .graph
2584 .contains(self.focus.focused_widget.unwrap_or_default())
2585 {
2586 self.focus.focused_widget = None;
2587 self.focused_semantics = None;
2588 }
2589 }
2590
2591 fn resolve_event_target(&self, event: &Event, hit_target: Option<WidgetId>) -> WidgetId {
2592 match event {
2593 Event::Pointer(pointer) => self
2594 .pointer_capture
2595 .get(&pointer.pointer_id)
2596 .copied()
2597 .or(hit_target)
2598 .unwrap_or(self.root.id()),
2599 Event::RawMouseMotion(_) => self
2600 .cursor
2601 .grab_owner
2602 .filter(|_| self.cursor.state.grab_mode != CursorGrabMode::None)
2603 .unwrap_or(self.root.id()),
2604 Event::Keyboard(_) | Event::Ime(_) => {
2605 self.focus.focused_widget.unwrap_or(self.root.id())
2606 }
2607 Event::Semantics(semantics) => self.semantics_route_target(semantics.target),
2608 Event::Wake(wake_event) => self.wake_target(*wake_event).unwrap_or(self.root.id()),
2609 _ => self.root.id(),
2610 }
2611 }
2612
2613 fn wake_target(&self, wake_event: WakeEvent) -> Option<WidgetId> {
2614 match wake_event {
2615 WakeEvent::Timer { token, .. } => self.delivering_timers.get(&token).copied(),
2616 WakeEvent::Async { token, .. } => self.async_wake_targets.get(&token).copied(),
2617 WakeEvent::AnimationFrame { .. } => self.delivering_animation_frames.front().copied(),
2618 }
2619 }
2620
2621 fn apply_event_effects(
2622 &mut self,
2623 effects: EventEffects,
2624 invalidations: &mut Vec<InvalidationRequest>,
2625 ) {
2626 invalidations.extend(effects.invalidations);
2627 self.apply_wake_requests(effects.wake_requests);
2628 self.apply_pointer_capture_requests(effects.pointer_capture_requests, invalidations);
2629 self.apply_cursor_requests(effects.cursor_requests);
2630 self.apply_drag_requests(effects.drag_requests, invalidations);
2631 self.apply_posted_events(effects.posted_events, invalidations);
2632 self.apply_posted_commands(effects.posted_commands, invalidations);
2633 }
2634
2635 fn apply_posted_events(
2639 &mut self,
2640 mut posted: Vec<widget::PostedEventRequest>,
2641 invalidations: &mut Vec<InvalidationRequest>,
2642 ) {
2643 const MAX_POSTED_EVENT_ROUNDS: usize = 8;
2644
2645 let mut rounds = 0;
2646 while !posted.is_empty() && rounds < MAX_POSTED_EVENT_ROUNDS {
2647 rounds += 1;
2648 for request in std::mem::take(&mut posted) {
2649 let dispatch = self.dispatch_direct_event(request.target, &request.event);
2650 invalidations.extend(dispatch.invalidations);
2651 self.apply_wake_requests(dispatch.wake_requests);
2652 self.apply_pointer_capture_requests(
2653 dispatch.pointer_capture_requests,
2654 invalidations,
2655 );
2656 self.apply_cursor_requests(dispatch.cursor_requests);
2657 self.apply_drag_requests(dispatch.drag_requests, invalidations);
2658 posted.extend(dispatch.posted_events);
2659 self.apply_posted_commands(dispatch.posted_commands, invalidations);
2660 if let Some(request) = dispatch.focus_request {
2661 let focus_effects = self.apply_focus_request(request);
2662 invalidations.extend(focus_effects.invalidations);
2663 self.apply_wake_requests(focus_effects.wake_requests);
2664 self.apply_pointer_capture_requests(
2665 focus_effects.pointer_capture_requests,
2666 invalidations,
2667 );
2668 self.apply_cursor_requests(focus_effects.cursor_requests);
2669 self.apply_drag_requests(focus_effects.drag_requests, invalidations);
2670 posted.extend(focus_effects.posted_events);
2671 self.apply_posted_commands(focus_effects.posted_commands, invalidations);
2672 }
2673 }
2674 }
2675 }
2676
2677 fn apply_posted_commands(
2678 &mut self,
2679 mut posted: Vec<widget::PostedCommandRequest>,
2680 invalidations: &mut Vec<InvalidationRequest>,
2681 ) {
2682 const MAX_POSTED_COMMAND_ROUNDS: usize = 8;
2683 let mut rounds = 0;
2684 while !posted.is_empty() && rounds < MAX_POSTED_COMMAND_ROUNDS {
2685 rounds += 1;
2686 for request in std::mem::take(&mut posted) {
2687 let CommandTarget::Widget { widget_id, .. } = request.command.target else {
2688 continue;
2689 };
2690 let Some(dispatch) = self.dispatch_direct_command(widget_id, &request.command)
2691 else {
2692 self.record_command_dispatch(command_sample(
2693 &request.command,
2694 Vec::new(),
2695 false,
2696 false,
2697 ));
2698 continue;
2699 };
2700 self.record_command_invalidations(
2701 &dispatch.invalidations,
2702 request.command.key.name,
2703 Some("posted by widget"),
2704 );
2705 invalidations.extend(dispatch.invalidations);
2706 self.apply_wake_requests(dispatch.wake_requests);
2707 self.apply_pointer_capture_requests(
2708 dispatch.pointer_capture_requests,
2709 invalidations,
2710 );
2711 self.apply_cursor_requests(dispatch.cursor_requests);
2712 self.apply_drag_requests(dispatch.drag_requests, invalidations);
2713 self.apply_posted_events(dispatch.posted_events, invalidations);
2714 posted.extend(dispatch.posted_commands);
2715 self.record_command_dispatch(command_sample(
2716 &request.command,
2717 vec!["widget target".to_string()],
2718 dispatch.handled,
2719 true,
2720 ));
2721 if let Some(focus_request) = dispatch.focus_request {
2722 let effects = self.apply_focus_request(focus_request);
2723 self.apply_event_effects(effects, invalidations);
2724 }
2725 }
2726 }
2727 }
2728
2729 fn apply_drag_requests(
2730 &mut self,
2731 requests: Vec<DragRequest>,
2732 invalidations: &mut Vec<InvalidationRequest>,
2733 ) {
2734 for request in requests {
2735 match request {
2736 DragRequest::Begin(request) => {
2737 self.active_drag = Some(ActiveDrag::from_request(request));
2738 invalidations.push(InvalidationRequest::new(
2739 InvalidationTarget::Window(self.id),
2740 InvalidationKind::Paint,
2741 ));
2742 }
2743 DragRequest::RefreshTargets => {
2744 self.drag_targets_stale = self.active_drag.is_some();
2745 }
2746 }
2747 }
2748 }
2749
2750 fn is_drag_pointer(&self, pointer: &PointerEvent) -> bool {
2751 self.active_drag
2752 .as_ref()
2753 .is_some_and(|drag| drag.pointer_id == pointer.pointer_id)
2754 }
2755
2756 fn refresh_active_drag(&mut self) -> EventEffects {
2758 let Some(position) = self.active_drag.as_ref().map(|drag| drag.position) else {
2759 return EventEffects::default();
2760 };
2761 let hit_target = self.pointer_hit_target(position);
2762 self.update_active_drag(position, hit_target)
2763 }
2764
2765 fn handle_drag_key_event(
2769 &mut self,
2770 key: &KeyboardEvent,
2771 invalidations: &mut Vec<InvalidationRequest>,
2772 ) -> bool {
2773 let Some(drag) = self.active_drag.as_mut() else {
2774 return false;
2775 };
2776 if key.state == KeyState::Pressed && key.key == "Escape" && !key.is_composing {
2777 let position = drag.position;
2778 let effects = self.finish_active_drag(position, true);
2779 self.apply_event_effects(effects, invalidations);
2780 return true;
2781 }
2782 let modifiers = drag_key_modifiers(key);
2783 if drag.modifiers != modifiers {
2784 drag.modifiers = modifiers;
2785 let effects = self.refresh_active_drag();
2786 self.apply_event_effects(effects, invalidations);
2787 }
2788 false
2789 }
2790
2791 fn handle_drag_pointer_event(
2792 &mut self,
2793 pointer: &PointerEvent,
2794 hit_target: Option<WidgetId>,
2795 ) -> EventEffects {
2796 if !self.is_drag_pointer(pointer) {
2797 return EventEffects::default();
2798 }
2799
2800 if let Some(drag) = self.active_drag.as_mut() {
2801 drag.modifiers = pointer.modifiers;
2802 }
2803 match pointer.kind {
2804 PointerEventKind::Move => self.update_active_drag(pointer.position, hit_target),
2805 PointerEventKind::Up => {
2806 let mut effects = self.update_active_drag(pointer.position, hit_target);
2807 effects.merge(self.finish_active_drag(pointer.position, false));
2808 effects
2809 }
2810 PointerEventKind::Cancel | PointerEventKind::Leave => {
2811 self.finish_active_drag(pointer.position, true)
2812 }
2813 _ => EventEffects::default(),
2814 }
2815 }
2816
2817 fn update_active_drag(
2818 &mut self,
2819 position: Point,
2820 hit_target: Option<WidgetId>,
2821 ) -> EventEffects {
2822 let Some((previous_path, active_snapshot)) = self.active_drag.as_mut().map(|active| {
2823 active.position = position;
2824 (active.hover_path.clone(), active.clone())
2825 }) else {
2826 return EventEffects::default();
2827 };
2828
2829 let next_path = hit_target
2830 .and_then(|target| self.graph.path_to(target))
2831 .unwrap_or_default();
2832
2833 let mut effects = EventEffects::default();
2834 effects.invalidations.push(InvalidationRequest::new(
2835 InvalidationTarget::Window(self.id),
2836 InvalidationKind::Paint,
2837 ));
2838
2839 let shared_prefix_len = previous_path
2840 .iter()
2841 .zip(next_path.iter())
2842 .take_while(|(left, right)| left == right)
2843 .count();
2844
2845 for widget_id in previous_path[shared_prefix_len..].iter().rev().copied() {
2846 let event = active_snapshot.event(
2847 DragEventKind::Leave,
2848 position,
2849 Some(widget_id),
2850 DropEffect::None,
2851 None,
2852 );
2853 effects.extend(self.dispatch_direct_event(widget_id, &event));
2854 }
2855
2856 for widget_id in next_path[shared_prefix_len..].iter().copied() {
2857 let event = active_snapshot.event(
2858 DragEventKind::Enter,
2859 position,
2860 Some(widget_id),
2861 DropEffect::None,
2862 None,
2863 );
2864 effects.extend(self.dispatch_direct_event(widget_id, &event));
2865 }
2866
2867 let mut accepted = None;
2868 if let Some(target) = hit_target {
2869 let event = active_snapshot.event(
2870 DragEventKind::Over,
2871 position,
2872 Some(target),
2873 DropEffect::None,
2874 None,
2875 );
2876 let route = self.route_event(target, &event);
2877 accepted = nearest_drop_acceptance(&route.effects.drop_acceptances, &route.path);
2878 if let Some(request) = route.focus_request {
2879 effects.merge(self.apply_focus_request(request));
2880 }
2881 effects.merge(route.effects);
2882 }
2883
2884 if let Some(active) = self.active_drag.as_mut() {
2885 active.hover_path = next_path;
2886 if let Some(accepted) = accepted {
2887 active.accepted_target = Some(accepted.target);
2888 active.accepted_effect = accepted.effect;
2889 } else {
2890 active.accepted_target = None;
2891 active.accepted_effect = DropEffect::None;
2892 }
2893 }
2894
2895 effects
2896 }
2897
2898 fn finish_active_drag(&mut self, position: Point, cancelled: bool) -> EventEffects {
2899 let Some(active) = self.active_drag.take() else {
2900 return EventEffects::default();
2901 };
2902 self.drag_targets_stale = false;
2903
2904 let mut effects = EventEffects::default();
2905 let outcome = if !cancelled {
2906 active
2907 .accepted_target
2908 .filter(|_| active.accepted_effect.is_some())
2909 .map(|target| DragOutcome::Dropped {
2910 target,
2911 effect: active.accepted_effect,
2912 })
2913 .unwrap_or(DragOutcome::Cancelled)
2914 } else {
2915 DragOutcome::Cancelled
2916 };
2917
2918 if let DragOutcome::Dropped { target, effect } = outcome {
2919 let event = active.event(
2920 DragEventKind::Drop,
2921 position,
2922 Some(target),
2923 effect,
2924 Some(outcome),
2925 );
2926 effects.extend(self.dispatch_direct_event(target, &event));
2927 }
2928
2929 for widget_id in active.hover_path.iter().rev().copied() {
2930 let event = active.event(
2931 DragEventKind::Leave,
2932 position,
2933 Some(widget_id),
2934 DropEffect::None,
2935 None,
2936 );
2937 effects.extend(self.dispatch_direct_event(widget_id, &event));
2938 }
2939
2940 let end_event = active.event(
2941 DragEventKind::End,
2942 position,
2943 active.accepted_target,
2944 active.accepted_effect,
2945 Some(outcome),
2946 );
2947 effects.extend(self.dispatch_direct_event(active.source, &end_event));
2948 effects.invalidations.push(InvalidationRequest::new(
2949 InvalidationTarget::Window(self.id),
2950 InvalidationKind::Paint,
2951 ));
2952 effects
2953 }
2954
2955 fn apply_wake_requests(&mut self, requests: Vec<WakeRequest>) {
2956 for request in requests {
2957 match request {
2958 WakeRequest::ScheduleTimer {
2959 token,
2960 deadline,
2961 target,
2962 } => {
2963 self.scheduled_timers.retain(|timer| timer.token != token);
2964 self.scheduled_timers.push(ScheduledTimer {
2965 token,
2966 deadline,
2967 target,
2968 });
2969 }
2970 WakeRequest::CancelTimer { token } => {
2971 self.scheduled_timers.retain(|timer| timer.token != token);
2972 self.delivering_timers.remove(&token);
2973 }
2974 WakeRequest::RegisterAsync { token, target } => {
2975 self.async_wake_targets.insert(token, target);
2976 }
2977 WakeRequest::UnregisterAsync { token } => {
2978 self.async_wake_targets.remove(&token);
2979 self.pending_async_wakeups.retain(|queued| *queued != token);
2980 }
2981 WakeRequest::RequestAnimationFrame { target } => {
2982 self.requested_animation_frames.insert(target);
2983 }
2984 WakeRequest::Motion {
2985 target,
2986 kind,
2987 until,
2988 } => {
2989 let end = self.active_motions.entry((target, kind)).or_insert(until);
2990 *end = end.max(until);
2991 }
2992 WakeRequest::MotionEnd {
2993 target,
2994 kind,
2995 until,
2996 } => {
2997 let ends = self.motion_ends.entry((target, kind)).or_default();
2998 if !ends.contains(&until) {
2999 ends.push(until);
3000 }
3001 }
3002 }
3003 }
3004 }
3005
3006 fn apply_pointer_capture_requests(
3007 &mut self,
3008 requests: Vec<PointerCaptureRequest>,
3009 invalidations: &mut Vec<InvalidationRequest>,
3010 ) {
3011 for request in requests {
3012 match request {
3013 PointerCaptureRequest::Capture { pointer_id, target } => {
3014 self.reconcile_pointer_capture(pointer_id, Some(target), invalidations);
3015 }
3016 PointerCaptureRequest::Release { pointer_id } => {
3017 self.pointer_capture.remove(&pointer_id);
3018 }
3019 }
3020 }
3021 }
3022
3023 fn apply_cursor_requests(&mut self, requests: Vec<CursorRequest>) {
3024 for request in requests {
3025 match request {
3026 CursorRequest::Grab { target, mode } => {
3027 if !self.focus.window_focused && mode != CursorGrabMode::None {
3028 continue;
3029 }
3030 if mode == CursorGrabMode::None {
3031 if self.cursor.grab_owner.is_some()
3032 && self.cursor.grab_owner != Some(target)
3033 {
3034 continue;
3035 }
3036 self.cursor.grab_owner = None;
3037 } else {
3038 self.cursor.grab_owner = Some(target);
3039 }
3040 self.cursor.state.grab_mode = mode;
3041 self.cursor.state.revision = self.cursor.state.revision.wrapping_add(1);
3042 }
3043 CursorRequest::Visibility { target, visible } => {
3044 if !self.focus.window_focused && !visible {
3045 continue;
3046 }
3047 if visible {
3048 if self.cursor.visibility_owner.is_some()
3049 && self.cursor.visibility_owner != Some(target)
3050 {
3051 continue;
3052 }
3053 self.cursor.visibility_owner = None;
3054 } else {
3055 self.cursor.visibility_owner = Some(target);
3056 }
3057 self.cursor.state.visible = visible;
3058 self.cursor.state.revision = self.cursor.state.revision.wrapping_add(1);
3059 }
3060 }
3061 }
3062 }
3063
3064 fn reset_cursor_state(&mut self) {
3065 if self.cursor.state.grab_mode == CursorGrabMode::None
3066 && self.cursor.state.visible
3067 && self.cursor.grab_owner.is_none()
3068 && self.cursor.visibility_owner.is_none()
3069 {
3070 return;
3071 }
3072
3073 self.cursor.state.grab_mode = CursorGrabMode::None;
3074 self.cursor.state.visible = true;
3075 self.cursor.state.revision = self.cursor.state.revision.wrapping_add(1);
3076 self.cursor.grab_owner = None;
3077 self.cursor.visibility_owner = None;
3078 }
3079
3080 fn cancel_all_pointer_captures(&mut self, invalidations: &mut Vec<InvalidationRequest>) {
3081 let pointer_ids = self.pointer_capture.keys().copied().collect::<Vec<_>>();
3082 for pointer_id in pointer_ids {
3083 self.reconcile_pointer_capture(pointer_id, None, invalidations);
3084 }
3085 }
3086
3087 fn reconcile_pointer_capture(
3088 &mut self,
3089 pointer_id: u64,
3090 requested_target: Option<WidgetId>,
3091 invalidations: &mut Vec<InvalidationRequest>,
3092 ) {
3093 let mut cancelled_owners = HashSet::new();
3094
3095 loop {
3096 let current = self.pointer_capture.get(&pointer_id).copied();
3097 match (current, requested_target) {
3098 (None, Some(target)) => {
3099 self.pointer_capture.insert(pointer_id, target);
3100 return;
3101 }
3102 (None, None) => return,
3103 (Some(owner), Some(target)) if owner == target => return,
3104 (Some(owner), _) => {
3105 self.pointer_capture.remove(&pointer_id);
3106 if !cancelled_owners.insert(owner) {
3107 continue;
3111 }
3112
3113 let cancel = self.pointer_cancel_event(pointer_id);
3114 let dispatch = self.dispatch_direct_event(owner, &Event::Pointer(cancel));
3115 self.apply_pointer_cancel_dispatch(dispatch, invalidations);
3116 }
3117 }
3118 }
3119 }
3120
3121 fn pointer_cancel_event(&self, pointer_id: u64) -> PointerEvent {
3122 let mut pointer = self
3123 .last_pointer_events
3124 .get(&pointer_id)
3125 .cloned()
3126 .unwrap_or_else(|| PointerEvent::new(PointerEventKind::Cancel, Point::ZERO));
3127 pointer.pointer_id = pointer_id;
3128 pointer.kind = PointerEventKind::Cancel;
3129 pointer.delta = Vector::ZERO;
3130 pointer.scroll_delta = None;
3131 pointer.button = None;
3132 pointer.buttons = PointerButtons::NONE;
3133 pointer
3134 }
3135
3136 fn apply_pointer_cancel_dispatch(
3137 &mut self,
3138 dispatch: widget::EventDispatch,
3139 invalidations: &mut Vec<InvalidationRequest>,
3140 ) {
3141 let focus_request = dispatch.focus_request;
3142 let mut effects = EventEffects::default();
3143 effects.extend(dispatch);
3144 self.apply_event_effects(effects, invalidations);
3145
3146 if let Some(request) = focus_request {
3147 let focus_effects = self.apply_focus_request(request);
3148 self.apply_event_effects(focus_effects, invalidations);
3149 }
3150 }
3151
3152 fn release_ime_hold(&mut self) {
3155 if self.touches_down.is_empty()
3156 && self.held_ime_composition_rect.take().is_some()
3157 && self.ime_composition_rect.is_none()
3158 {
3159 self.schedule.mark(InvalidationKind::Paint);
3160 }
3161 }
3162
3163 fn finish_event(&mut self, event: &Event) {
3164 match event {
3165 Event::Pointer(pointer)
3166 if matches!(
3167 pointer.kind,
3168 PointerEventKind::Up | PointerEventKind::Cancel
3169 ) =>
3170 {
3171 self.pointer_capture.remove(&pointer.pointer_id);
3172 self.last_pointer_events.remove(&pointer.pointer_id);
3173 if self.touches_down.remove(&pointer.pointer_id) {
3174 self.release_ime_hold();
3175 }
3176 }
3177 Event::Wake(WakeEvent::Timer { token, .. }) => {
3178 self.delivering_timers.remove(token);
3179 }
3180 Event::Wake(WakeEvent::AnimationFrame { .. }) => {
3181 self.delivering_animation_frames.pop_front();
3182 if self.delivering_animation_frames.is_empty() && !self.wants_animation_frame() {
3183 self.last_animation_frame_time = None;
3184 }
3185 }
3186 _ => {}
3187 }
3188 }
3189
3190 fn route_event(&mut self, target: WidgetId, event: &Event) -> EventRouteResult {
3191 let path = self
3192 .graph
3193 .path_to(target)
3194 .unwrap_or_else(|| vec![self.root.id()]);
3195 let dpi_info = self.current_dpi_info();
3196 let mut effects = EventEffects::default();
3197 let mut handled = false;
3198 let mut focus_request = None;
3199 let mut route_steps = self.inspector_tracing_enabled.then(Vec::new);
3200 let target_only = matches!(event, Event::Wake(_));
3201 let ignore_handled = matches!(event, Event::Drag(_));
3202
3203 if !target_only && path.len() > 1 {
3204 for path_len in 1..path.len() {
3205 let dispatch = self
3206 .root
3207 .dispatch_event_for_path(
3208 &path[..path_len],
3209 self.id,
3210 dpi_info,
3211 self.last_tick_time,
3212 EventPhase::Capture,
3213 self.focus.focused_widget,
3214 &self.services,
3215 &self.command_sender,
3216 event,
3217 )
3218 .unwrap_or_else(empty_dispatch);
3219 let dispatch_handled = dispatch.handled;
3220 let dispatch_focus_request = dispatch.focus_request;
3221 if let Some(route_steps) = &mut route_steps {
3222 route_steps.push(EventRouteStep {
3223 widget_id: path[path_len - 1],
3224 phase: EventRoutePhase::Capture,
3225 handled: dispatch_handled,
3226 });
3227 }
3228 effects.extend(dispatch);
3229 if dispatch_focus_request.is_some() {
3230 focus_request = dispatch_focus_request;
3231 }
3232 if dispatch_handled && !ignore_handled {
3233 handled = true;
3234 break;
3235 }
3236 }
3237 }
3238
3239 if !handled || ignore_handled {
3240 let dispatch = self
3241 .root
3242 .dispatch_event_for_path(
3243 &path,
3244 self.id,
3245 dpi_info,
3246 self.last_tick_time,
3247 EventPhase::Target,
3248 self.focus.focused_widget,
3249 &self.services,
3250 &self.command_sender,
3251 event,
3252 )
3253 .or_else(|| {
3254 self.root.dispatch_event_for(
3255 target,
3256 self.id,
3257 dpi_info,
3258 self.last_tick_time,
3259 EventPhase::Target,
3260 self.focus.focused_widget,
3261 &self.services,
3262 &self.command_sender,
3263 event,
3264 )
3265 })
3266 .unwrap_or_else(empty_dispatch);
3267 let dispatch_handled = dispatch.handled;
3268 let dispatch_focus_request = dispatch.focus_request;
3269 if let Some(route_steps) = &mut route_steps {
3270 route_steps.push(EventRouteStep {
3271 widget_id: target,
3272 phase: EventRoutePhase::Target,
3273 handled: dispatch_handled,
3274 });
3275 }
3276 effects.extend(dispatch);
3277 if dispatch_focus_request.is_some() {
3278 focus_request = dispatch_focus_request;
3279 }
3280 handled = dispatch_handled && !ignore_handled;
3281 }
3282
3283 if !target_only && (!handled || ignore_handled) && path.len() > 1 {
3284 for path_len in (1..path.len()).rev() {
3285 let dispatch = self
3286 .root
3287 .dispatch_event_for_path(
3288 &path[..path_len],
3289 self.id,
3290 dpi_info,
3291 self.last_tick_time,
3292 EventPhase::Bubble,
3293 self.focus.focused_widget,
3294 &self.services,
3295 &self.command_sender,
3296 event,
3297 )
3298 .unwrap_or_else(empty_dispatch);
3299 let dispatch_handled = dispatch.handled;
3300 let dispatch_focus_request = dispatch.focus_request;
3301 if let Some(route_steps) = &mut route_steps {
3302 route_steps.push(EventRouteStep {
3303 widget_id: path[path_len - 1],
3304 phase: EventRoutePhase::Bubble,
3305 handled: dispatch_handled,
3306 });
3307 }
3308 effects.extend(dispatch);
3309 if dispatch_focus_request.is_some() {
3310 focus_request = dispatch_focus_request;
3311 }
3312 if dispatch_handled && !ignore_handled {
3313 handled = true;
3314 break;
3315 }
3316 }
3317 }
3318
3319 if let Some(route_steps) = route_steps {
3320 let trace_handled = route_steps.iter().any(|step| step.handled);
3321 let sample = EventRouteTraceSample {
3322 sequence: self.next_event_route_sequence,
3323 event_kind: inspector_event_kind(event),
3324 target,
3325 path: path.clone(),
3326 steps: route_steps,
3327 handled: trace_handled,
3328 };
3329 self.next_event_route_sequence = self.next_event_route_sequence.wrapping_add(1);
3330 push_inspector_history(&mut self.event_route_history, sample);
3331 }
3332
3333 EventRouteResult {
3334 path,
3335 effects,
3336 focus_request,
3337 handled,
3338 }
3339 }
3340
3341 fn default_focus_request(
3342 &self,
3343 event: &Event,
3344 hit_target: Option<WidgetId>,
3345 path: &[WidgetId],
3346 ) -> Option<FocusRequest> {
3347 match event {
3348 Event::Keyboard(keyboard)
3349 if keyboard.state == KeyState::Pressed
3350 && keyboard.key == "Tab"
3351 && !keyboard.repeat
3352 && !keyboard.is_composing
3353 && !keyboard.modifiers.control
3354 && !keyboard.modifiers.alt
3355 && !keyboard.modifiers.meta =>
3356 {
3357 self.overlay_manager
3358 .focus_trap()
3359 .and_then(|scope| {
3360 self.graph.next_focusable_within(
3361 scope,
3362 self.focus.focused_widget,
3363 keyboard.modifiers.shift,
3364 )
3365 })
3366 .or_else(|| {
3367 self.graph
3368 .next_focusable(self.focus.focused_widget, keyboard.modifiers.shift)
3369 })
3370 .map(FocusRequest::Focus)
3371 .or(Some(FocusRequest::Clear))
3372 }
3373 Event::Pointer(pointer) if pointer.kind == PointerEventKind::Down => {
3374 let Some(hit_target) = hit_target else {
3375 return Some(FocusRequest::Clear);
3376 };
3377
3378 path.iter()
3379 .rev()
3380 .copied()
3381 .find(|widget_id| {
3382 self.graph
3383 .node(*widget_id)
3384 .is_some_and(|node| node.accepts_focus)
3385 })
3386 .map(FocusRequest::Focus)
3387 .or(Some(FocusRequest::Clear))
3388 .filter(|request| {
3389 matches!(request, FocusRequest::Focus(id) if *id == hit_target)
3390 || matches!(request, FocusRequest::Clear)
3391 })
3392 }
3393 Event::Window(WindowEvent::Focused(false)) => Some(FocusRequest::Clear),
3394 _ => None,
3395 }
3396 }
3397
3398 fn apply_focus_request(&mut self, request: FocusRequest) -> EventEffects {
3399 let request = self.constrain_focus_request(request);
3400 self.apply_focus_request_unconstrained(request)
3401 }
3402
3403 fn apply_focus_request_unconstrained(&mut self, request: FocusRequest) -> EventEffects {
3404 let next_focus = match request {
3405 FocusRequest::Focus(widget_id) => Some(widget_id),
3406 FocusRequest::Clear => None,
3407 FocusRequest::Keep => return EventEffects::default(),
3408 };
3409
3410 if self.focus.focused_widget == next_focus {
3411 if self.focused_semantics != next_focus {
3412 self.focused_semantics = next_focus;
3413 self.schedule.mark(InvalidationKind::Semantics);
3414 }
3415 return EventEffects::default();
3416 }
3417
3418 let previous_focus = self.focus.focused_widget;
3419 self.focus.focused_widget = next_focus;
3420 self.focused_semantics = next_focus;
3421 let dpi_info = self.current_dpi_info();
3422
3423 let mut effects = EventEffects::default();
3424
3425 if let Some(widget_id) = previous_focus {
3426 effects
3427 .invalidations
3428 .extend(self.focus_transition_invalidations(widget_id));
3429 let extra = self
3430 .graph
3431 .path_to(widget_id)
3432 .and_then(|path| {
3433 self.root.notify_focus_change_for_path(
3434 &path,
3435 self.id,
3436 dpi_info,
3437 self.last_tick_time,
3438 self.focus.focused_widget,
3439 &self.services,
3440 &self.command_sender,
3441 false,
3442 )
3443 })
3444 .or_else(|| {
3445 self.root.notify_focus_change_for(
3446 widget_id,
3447 self.id,
3448 dpi_info,
3449 self.last_tick_time,
3450 self.focus.focused_widget,
3451 &self.services,
3452 &self.command_sender,
3453 false,
3454 )
3455 });
3456 if let Some(extra) = extra {
3457 effects.extend(extra);
3458 }
3459 }
3460
3461 if let Some(widget_id) = next_focus {
3462 effects
3463 .invalidations
3464 .extend(self.focus_transition_invalidations(widget_id));
3465 let extra = self
3466 .graph
3467 .path_to(widget_id)
3468 .and_then(|path| {
3469 self.root.notify_focus_change_for_path(
3470 &path,
3471 self.id,
3472 dpi_info,
3473 self.last_tick_time,
3474 self.focus.focused_widget,
3475 &self.services,
3476 &self.command_sender,
3477 true,
3478 )
3479 })
3480 .or_else(|| {
3481 self.root.notify_focus_change_for(
3482 widget_id,
3483 self.id,
3484 dpi_info,
3485 self.last_tick_time,
3486 self.focus.focused_widget,
3487 &self.services,
3488 &self.command_sender,
3489 true,
3490 )
3491 });
3492 if let Some(extra) = extra {
3493 effects.extend(extra);
3494 }
3495 }
3496
3497 self.schedule.mark(InvalidationKind::Paint);
3498 self.schedule.mark(InvalidationKind::Semantics);
3499 self.schedule.mark(InvalidationKind::HitTest);
3500 self.graph.set_focused_widget(self.focus.focused_widget);
3501
3502 effects
3503 }
3504
3505 fn constrain_focus_request(&self, request: FocusRequest) -> FocusRequest {
3506 let Some(scope) = self.overlay_manager.focus_trap() else {
3507 return request;
3508 };
3509 match request {
3510 FocusRequest::Focus(widget_id)
3511 if widget_id == scope || self.graph.is_ancestor_of(scope, widget_id) =>
3512 {
3513 return request;
3514 }
3515 FocusRequest::Keep => return request,
3516 FocusRequest::Focus(_) | FocusRequest::Clear => {}
3517 }
3518
3519 self.focus
3520 .focused_widget
3521 .filter(|focused| *focused == scope || self.graph.is_ancestor_of(scope, *focused))
3522 .or_else(|| self.graph.first_focusable_within(scope, true))
3523 .map(FocusRequest::Focus)
3524 .unwrap_or(FocusRequest::Clear)
3525 }
3526
3527 fn apply_pending_overlay_focus(&mut self, invalidations: &mut Vec<InvalidationRequest>) {
3528 let Some(request) = self.pending_overlay_focus.take() else {
3529 return;
3530 };
3531 let effects = self.apply_focus_request(request);
3532 self.apply_event_effects(effects, invalidations);
3533 }
3534
3535 fn focus_transition_invalidations(&self, widget_id: WidgetId) -> Vec<InvalidationRequest> {
3536 let mut invalidations = vec![InvalidationRequest::new(
3537 InvalidationTarget::Widget(widget_id),
3538 InvalidationKind::Semantics,
3539 )];
3540
3541 if let Some(node) = self.graph.node(widget_id) {
3542 invalidations.push(
3543 InvalidationRequest::new(
3544 InvalidationTarget::Widget(widget_id),
3545 InvalidationKind::Paint,
3546 )
3547 .with_region(node.geometry.paint_bounds),
3548 );
3549 }
3550
3551 invalidations
3552 }
3553
3554 fn render(
3555 &mut self,
3556 text_system: Arc<TextSystem>,
3557 font_registry: Arc<FontRegistry>,
3558 image_registry: Arc<ImageRegistry>,
3559 ) -> RenderOutput {
3560 let diagnostics_enabled = window_scene_statistics_detail_mode(self.id).is_detailed();
3561 let mut diagnostics = RenderDiagnostics::default();
3562 let mut invalidations = std::mem::take(&mut self.pending_invalidations);
3563 let local_output = std::mem::take(&mut self.pending_local_output);
3564 let mut repainted = false;
3565 let mut repaint_layers = Vec::new();
3566 let mut dirty_layers = Vec::new();
3567 let mut layer_updates = Vec::new();
3568 let root_repaint_covers_graph_changes =
3569 root_repaint_covers_graph_changes(self.root.id(), &invalidations);
3570 let diff_graph = !root_repaint_covers_graph_changes
3573 && (self.previous_graph_saved
3574 || ((self.schedule.measure || self.schedule.arrange) && !self.graph.is_empty()));
3575 let mut graph_changes = GraphChangeSet::default();
3576
3577 if self.schedule.measure || self.schedule.arrange || self.viewport.is_none() {
3581 let started = Instant::now();
3582 let pass_invalidations = self.run_measure_arrange_pass(
3583 &invalidations,
3584 Arc::clone(&text_system),
3585 Arc::clone(&font_registry),
3586 Arc::clone(&image_registry),
3587 );
3588 self.schedule.extend(&pass_invalidations);
3589 invalidations.extend(pass_invalidations);
3590 graph_changes = if root_repaint_covers_graph_changes {
3591 GraphChangeSet::default()
3592 } else {
3593 self.collect_graph_changes(
3594 (diff_graph && self.previous_graph_saved).then_some(&self.previous_graph),
3595 )
3596 };
3597 if diagnostics_enabled {
3598 diagnostics.push(FramePhase::MeasureArrange, started.elapsed());
3599 }
3600 } else {
3601 if self.schedule.hit_test || self.graph.is_empty() {
3602 let started = Instant::now();
3603 self.refresh_graph();
3604 if diagnostics_enabled {
3605 diagnostics.push(FramePhase::HitTest, started.elapsed());
3606 }
3607 }
3608 if diff_graph && self.previous_graph_saved {
3609 graph_changes = self.collect_graph_changes(Some(&self.previous_graph));
3610 }
3611 }
3612
3613 self.previous_graph_saved = false;
3614 self.apply_pending_overlay_focus(&mut invalidations);
3615
3616 let viewport = self.viewport.unwrap_or(Size::ZERO);
3617 let dpi_info = self.dpi_info_for_viewport(viewport);
3618 self.prepare_output_reuse(
3619 &invalidations,
3620 &local_output,
3621 &graph_changes,
3622 dpi_info,
3623 Arc::clone(&font_registry),
3624 Arc::clone(&image_registry),
3625 );
3626 let previous_scene = self.last_frame.as_ref().map(|frame| &frame.scene);
3627 let mut composition_only_transforms = self
3628 .select_composition_only_transforms(previous_scene, &graph_changes.transform_widgets);
3629 for translation in
3630 self.select_explicit_transform_translations(previous_scene, &invalidations)
3631 {
3632 if composition_only_transforms
3633 .iter()
3634 .all(|existing| existing.widget_id != translation.widget_id)
3635 {
3636 composition_only_transforms.push(translation);
3637 }
3638 }
3639 let previous_scene_for_refresh = self.last_frame.as_ref().map(|frame| frame.scene.clone());
3640 let layer_descriptor_refreshes = self.collect_explicit_layer_descriptor_refreshes(
3641 previous_scene_for_refresh.as_ref(),
3642 &invalidations,
3643 );
3644 let composition_only_transform_ids = composition_only_transforms
3645 .iter()
3646 .map(|translation| translation.widget_id)
3647 .collect::<HashSet<_>>();
3648 let mut repaint_graph_widgets = graph_changes.repaint_widgets.clone();
3649 for translation in &graph_changes.transform_widgets {
3650 if !composition_only_transform_ids.contains(&translation.widget_id) {
3651 repaint_graph_widgets.push(translation.widget_id);
3652 }
3653 }
3654
3655 if self.schedule.paint || self.last_frame.is_none() || !repaint_graph_widgets.is_empty() {
3656 repaint_layers = self.collect_dirty_layers(&invalidations);
3657 dirty_layers = repaint_layers.clone();
3658 for widget_id in repaint_graph_widgets.iter().copied() {
3659 if self.graph.contains(widget_id) && !dirty_layers.contains(&widget_id) {
3660 dirty_layers.push(widget_id);
3661 }
3662 if self.graph.contains(widget_id) && !repaint_layers.contains(&widget_id) {
3663 repaint_layers.push(widget_id);
3664 }
3665 }
3666
3667 let mixed_update_roots = composition_only_transforms
3672 .iter()
3673 .filter(|translation| {
3674 dirty_layers.iter().any(|dirty_widget| {
3675 self.widget_is_ancestor_of(translation.widget_id, *dirty_widget)
3676 })
3677 })
3678 .map(|translation| translation.widget_id)
3679 .collect::<Vec<_>>();
3680 repaint_layers.extend(mixed_update_roots.iter().copied());
3681 dirty_layers.extend(mixed_update_roots);
3682 self.minimize_layer_roots(&mut repaint_layers);
3683 self.minimize_layer_roots(&mut dirty_layers);
3684
3685 composition_only_transforms.retain(|translation| {
3686 !dirty_layers.iter().any(|dirty_widget| {
3687 *dirty_widget == translation.widget_id
3688 || self.widget_is_ancestor_of(*dirty_widget, translation.widget_id)
3689 })
3690 });
3691 }
3692
3693 let mut scene_changed = false;
3694 let has_ordering_updates = invalidations
3695 .iter()
3696 .any(|request| request.kind == InvalidationKind::Ordering);
3697 if self.last_frame.is_none()
3698 || !repaint_layers.is_empty()
3699 || !composition_only_transforms.is_empty()
3700 || !layer_descriptor_refreshes.is_empty()
3701 || has_ordering_updates
3702 {
3703 let started = Instant::now();
3704 repainted = self.last_frame.is_none() || !repaint_layers.is_empty();
3705 scene_changed = true;
3706
3707 let focused_path = self
3708 .focus
3709 .focused_widget
3710 .and_then(|widget_id| self.graph.path_to(widget_id));
3711 let preserve_ime = focused_path.as_ref().is_none_or(|path| {
3712 !repaint_layers
3713 .iter()
3714 .any(|widget_id| path.iter().any(|candidate| candidate == widget_id))
3715 });
3716 let baseline_ime_composition_rect = if preserve_ime {
3717 self.ime_composition_rect
3718 } else {
3719 None
3720 };
3721
3722 let (scene, paint_images, mut paint_bounds_by_widget, mut ime_composition_rect) =
3723 if self.last_frame.is_none() || repaint_layers.contains(&self.root.id()) {
3724 self.paint_full_scene(
3725 dpi_info,
3726 Arc::clone(&text_system),
3727 Arc::clone(&font_registry),
3728 Arc::clone(&image_registry),
3729 )
3730 } else if repaint_layers.is_empty() {
3731 (
3732 self.last_frame
3733 .as_ref()
3734 .map(|frame| frame.scene.clone())
3735 .unwrap_or_default(),
3736 Vec::new(),
3737 std::mem::take(&mut self.last_paint_bounds_by_widget),
3739 baseline_ime_composition_rect,
3740 )
3741 } else {
3742 self.repaint_dirty_layers(
3743 dpi_info,
3744 &repaint_layers,
3745 baseline_ime_composition_rect,
3746 Arc::clone(&text_system),
3747 Arc::clone(&font_registry),
3748 Arc::clone(&image_registry),
3749 )
3750 };
3751 let mut scene = scene;
3752 for translation in &composition_only_transforms {
3753 let _ = scene.translate_layer(translation.widget_id, translation.delta);
3754 for widget_id in self.graph.subtree_ids(translation.widget_id) {
3755 if let Some(bounds) = paint_bounds_by_widget.get_mut(&widget_id) {
3756 *bounds = bounds.translate(translation.delta);
3757 }
3758 }
3759 if let Some(moved_bounds) =
3760 paint_bounds_by_widget.get(&translation.widget_id).copied()
3761 {
3762 let mut ancestor = self
3768 .graph
3769 .node(translation.widget_id)
3770 .and_then(|node| node.parent);
3771 while let Some(widget_id) = ancestor {
3772 paint_bounds_by_widget
3773 .entry(widget_id)
3774 .and_modify(|bounds| *bounds = bounds.union(moved_bounds))
3775 .or_insert(moved_bounds);
3776 ancestor = self.graph.node(widget_id).and_then(|node| node.parent);
3777 }
3778 }
3779 if focused_path
3780 .as_ref()
3781 .is_some_and(|path| path.contains(&translation.widget_id))
3782 {
3783 ime_composition_rect =
3784 ime_composition_rect.map(|rect| rect.translate(translation.delta));
3785 }
3786 }
3787 for refresh in &layer_descriptor_refreshes {
3788 let _ =
3789 scene.replace_layer_descriptor(refresh.widget_id, refresh.descriptor.clone());
3790 }
3791 self.sync_scene_stack_metadata(&mut scene);
3792 self.last_paint_bounds_by_widget = paint_bounds_by_widget;
3793 self.graph
3794 .update_paint_bounds_from_snapshot(&self.last_paint_bounds_by_widget);
3795 self.ime_composition_rect = ime_composition_rect;
3796 let previous_scene = self.last_frame.as_ref().map(|frame| &frame.scene);
3797 layer_updates = self.collect_layer_updates(
3798 previous_scene,
3799 &scene,
3800 &invalidations,
3801 &dirty_layers,
3802 &composition_only_transforms
3803 .iter()
3804 .map(|translation| translation.widget_id)
3805 .collect::<Vec<_>>(),
3806 );
3807 let frame_image_registry =
3808 self.frame_image_registry(Arc::clone(&image_registry), paint_images);
3809 if text_system.text_layout_registry().len()
3813 > self.retained_text_layout_count + TEXT_LAYOUT_PRUNE_SLACK
3814 {
3815 retain_text_layouts_for_scene(text_system.as_ref(), &scene);
3816 self.retained_text_layout_count = text_system.text_layout_registry().len();
3817 }
3818 self.last_frame = Some(SceneFrame {
3819 window_id: self.id,
3820 viewport,
3821 surface_size: dpi_info.surface_size,
3822 scale_factor: dpi_info.scale_factor,
3823 dirty_regions: Vec::new(),
3824 layer_updates: layer_updates.clone(),
3825 scene,
3826 font_registry: Arc::clone(&font_registry),
3827 image_registry: frame_image_registry,
3828 text_layout_registry: text_system.text_layout_registry(),
3829 });
3830 if diagnostics_enabled && repainted {
3831 diagnostics.push(FramePhase::Paint, started.elapsed());
3832 }
3833 }
3834
3835 if self.schedule.semantics || self.last_semantics.is_empty() {
3836 let started = Instant::now();
3837 let mut semantics_ctx = SemanticsCtx::new(
3838 self.id,
3839 self.root.id(),
3840 self.root.id(),
3841 self.root.bounds(),
3842 self.focus.focused_widget,
3843 );
3844 semantics_ctx.output_cache = output_cache::OutputCache::scope(&self.output_cache);
3845 self.root.semantics(&mut semantics_ctx);
3846 let semantics = self.assemble_semantics_tree(semantics_ctx.into_nodes());
3847 self.last_semantics = self.filter_modal_semantics(semantics);
3848 if diagnostics_enabled {
3849 diagnostics.push(FramePhase::Semantics, started.elapsed());
3850 }
3851 }
3852
3853 let viewport_rect = Rect::from_origin_size(Point::ZERO, viewport);
3854 let dirty_regions = collect_dirty_regions(viewport, &invalidations, repainted, |request| {
3855 self.default_dirty_region_for_request(viewport_rect, request)
3856 });
3857 let mut frame = self
3858 .last_frame
3859 .clone()
3860 .unwrap_or_else(|| SceneFrame::new(self.id, viewport));
3861 frame.viewport = viewport;
3862 frame.surface_size = dpi_info.surface_size;
3863 frame.scale_factor = dpi_info.scale_factor;
3864 frame.dirty_regions = dirty_regions;
3865 frame.layer_updates = if scene_changed {
3866 layer_updates
3867 } else {
3868 self.collect_layer_updates(
3869 self.last_frame.as_ref().map(|stored| &stored.scene),
3870 &frame.scene,
3871 &invalidations,
3872 &[],
3873 &composition_only_transforms
3874 .iter()
3875 .map(|translation| translation.widget_id)
3876 .collect::<Vec<_>>(),
3877 )
3878 };
3879 frame.font_registry = font_registry;
3880 frame.image_registry = self.frame_image_registry(image_registry, Vec::new());
3881
3882 if diagnostics_enabled {
3883 let layout_cache = text_system.layout_cache_snapshot();
3884 diagnostics.text_caches.runtime_layout =
3885 CacheMetrics::new(layout_cache.entries, layout_cache.hits, layout_cache.misses);
3886 }
3887
3888 diagnostics.widget_count = self.graph.nodes.len();
3889 diagnostics.runtime_text_timing = sui_text::take_text_timing_collection();
3890 diagnostics.widget_timings = diagnostics::take_widget_timing_collection();
3891 diagnostics.reactive_invalidations = std::mem::take(&mut self.pending_reactive_diagnostics);
3892 diagnostics.command_dispatches = std::mem::take(&mut self.pending_command_diagnostics);
3893 diagnostics.invalidations = std::mem::take(&mut self.pending_invalidation_diagnostics);
3894 diagnostics.widget_rebuilds = diagnostics::take_widget_rebuilds(self.id);
3895 diagnostics.active_animated_widget_count = self.active_animated_widget_count();
3896 diagnostics.animation_frame_wake_count = self.pending_animation_wake_count;
3897 diagnostics.animation_repaint_frame_count =
3898 usize::from(self.pending_animation_wake_count > 0 && repainted);
3899 diagnostics.animation_transform_effect_only_frame_count = usize::from(
3900 self.pending_animation_wake_count > 0
3901 && self.animation_frame_is_transform_only(repainted, &frame.layer_updates),
3902 );
3903 self.pending_animation_wake_count = 0;
3904
3905 self.capture_inspector_diagnostics(&diagnostics);
3906
3907 self.schedule.clear();
3908
3909 RenderOutput {
3910 title: self.title.clone(),
3911 frame,
3912 semantics: self.last_semantics.clone(),
3913 ime_composition_rect: self.ime_composition_rect.or(self.held_ime_composition_rect),
3914 diagnostics,
3915 }
3916 }
3917
3918 fn frame_image_registry(
3919 &mut self,
3920 base: Arc<ImageRegistry>,
3921 paint_images: Vec<(ImageHandle, PaintImageResource)>,
3922 ) -> Arc<ImageRegistry> {
3923 if paint_images.is_empty()
3924 && self
3925 .last_image_registry_base
3926 .as_ref()
3927 .is_some_and(|last| Arc::ptr_eq(last, &base))
3928 && let Some(frame) = &self.last_frame
3929 {
3930 return Arc::clone(&frame.image_registry);
3931 }
3932 self.last_image_registry_base = Some(Arc::clone(&base));
3933 let mut registry = self
3934 .last_frame
3935 .as_ref()
3936 .map(|frame| frame.image_registry.as_ref().clone())
3937 .unwrap_or_else(|| base.as_ref().clone());
3938 for (handle, image) in base.iter() {
3939 registry.insert(handle, image.clone());
3940 }
3941 for (handle, image) in base.iter_external() {
3942 registry.insert_external(handle, *image);
3943 }
3944 for (handle, image) in paint_images {
3945 match image {
3946 PaintImageResource::Cpu(image) => {
3947 registry.insert(handle, image);
3948 }
3949 PaintImageResource::External(image) => {
3950 registry.insert_external(handle, image);
3951 }
3952 }
3953 }
3954 Arc::new(registry)
3955 }
3956
3957 fn prepare_output_reuse(
3958 &mut self,
3959 invalidations: &[InvalidationRequest],
3960 local_output: &HashMap<(WidgetId, InvalidationKind), usize>,
3961 changes: &GraphChangeSet,
3962 dpi: DpiInfo,
3963 fonts: Arc<FontRegistry>,
3964 images: Arc<ImageRegistry>,
3965 ) {
3966 if invalidations.is_empty()
3967 && changes.output_widgets.is_empty()
3968 && !self.schedule.paint
3969 && !self.schedule.semantics
3970 {
3971 self.output_cache.borrow_mut().next_frame();
3974 return;
3975 }
3976 let mut cache = self.output_cache.borrow_mut();
3977 cache.next_frame();
3978 cache.context(
3979 dpi,
3980 self.focus.focused_widget,
3981 fonts,
3982 images,
3983 window_render_options(self.id),
3984 );
3985 if self.last_frame.is_none() {
3986 cache.clear();
3987 return;
3988 }
3989 let mut explicit_full_paint = false;
3994 let mut explicit_full_semantics = false;
3995 for request in invalidations {
3996 let full = match request.target {
3997 InvalidationTarget::Widget(id) => {
3998 id == self.root.id() && !local_output.contains_key(&(id, request.kind))
3999 }
4000 _ => true,
4001 };
4002 if full {
4003 match request.kind {
4004 InvalidationKind::Paint | InvalidationKind::Effect => {
4005 explicit_full_paint = true
4006 }
4007 InvalidationKind::Semantics => explicit_full_semantics = true,
4008 _ => {
4009 explicit_full_paint = true;
4010 explicit_full_semantics = true;
4011 }
4012 }
4013 }
4014 }
4015 if (explicit_full_paint && explicit_full_semantics)
4016 || (!changes.output_widgets.is_empty()
4017 && changes.output_widgets.len().saturating_mul(2) >= self.graph.nodes.len())
4018 {
4019 cache.disable_paint();
4020 cache.disable_semantics();
4021 return;
4022 }
4023 let mut counts = HashMap::<_, usize>::new();
4024 for request in invalidations {
4025 if let InvalidationTarget::Widget(id) = request.target
4026 && local_output.contains_key(&(id, request.kind))
4027 {
4028 *counts.entry((id, request.kind)).or_default() += 1;
4029 }
4030 }
4031 let mut paint_dirty = HashSet::new();
4032 let mut semantics_dirty = HashSet::new();
4033 let mut full_paint = invalidations.is_empty() && self.schedule.paint;
4034 let mut full_semantics = invalidations.is_empty() && self.schedule.semantics;
4035 for id in &changes.output_widgets {
4038 paint_dirty.insert(*id);
4039 semantics_dirty.insert(*id);
4040 if let Some(path) = self.graph.path_to(*id) {
4041 paint_dirty.extend(path.iter().copied());
4042 semantics_dirty.extend(path);
4043 }
4044 }
4045 for request in invalidations {
4046 let (paint, semantics) = match request.kind {
4047 InvalidationKind::Paint | InvalidationKind::Effect => (true, false),
4048 InvalidationKind::Semantics => (false, true),
4049 _ => (true, true),
4050 };
4051 let InvalidationTarget::Widget(id) = request.target else {
4052 full_paint |= paint;
4053 full_semantics |= semantics;
4054 continue;
4055 };
4056 let local = local_output
4057 .get(&(id, request.kind))
4058 .is_some_and(|count| counts.get(&(id, request.kind)) == Some(count));
4059 if !self.graph.contains(id) || (id == self.root.id() && !local) {
4060 full_paint |= paint;
4061 full_semantics |= semantics;
4062 continue;
4063 }
4064 let nodes = if local {
4065 vec![id]
4066 } else {
4067 self.graph.subtree_ids(id)
4068 };
4069 if paint {
4070 paint_dirty.extend(nodes.iter().copied());
4071 }
4072 if semantics {
4073 semantics_dirty.extend(nodes);
4074 }
4075 if let Some(path) = self.graph.path_to(id) {
4076 if paint {
4077 paint_dirty.extend(path.iter().copied());
4078 }
4079 if semantics {
4080 semantics_dirty.extend(path);
4081 }
4082 }
4083 }
4084 if full_paint || paint_dirty.len().saturating_mul(2) >= self.graph.nodes.len() {
4087 cache.disable_paint();
4088 }
4089 if full_semantics || semantics_dirty.len().saturating_mul(2) >= self.graph.nodes.len() {
4090 cache.disable_semantics();
4091 }
4092 cache.retain(
4093 |id| self.graph.contains(id) && !paint_dirty.contains(&id),
4094 |id| self.graph.contains(id) && !semantics_dirty.contains(&id),
4095 );
4096 }
4097
4098 fn paint_full_scene(
4099 &mut self,
4100 dpi_info: DpiInfo,
4101 text_system: Arc<TextSystem>,
4102 font_registry: Arc<FontRegistry>,
4103 image_registry: Arc<ImageRegistry>,
4104 ) -> PaintOutput {
4105 let mut paint_ctx = PaintCtx::new(
4106 self.id,
4107 self.root.id(),
4108 self.root.bounds(),
4109 self.focus.focused_widget,
4110 dpi_info,
4111 text_system,
4112 font_registry,
4113 self.last_frame
4114 .as_ref()
4115 .map(|frame| Arc::clone(&frame.image_registry))
4116 .unwrap_or(image_registry),
4117 )
4118 .with_frame_time(self.frame_time());
4119 paint_ctx.output_cache = output_cache::OutputCache::scope(&self.output_cache);
4120 let _ = self
4121 .root
4122 .paint_layer_contents_for(self.root.id(), &mut paint_ctx);
4123 let (scene, images, paint_bounds, ime_composition_rect) = paint_ctx.into_parts();
4124 (
4125 scene,
4126 images,
4127 paint_bounds.into_iter().collect(),
4128 ime_composition_rect,
4129 )
4130 }
4131
4132 fn repaint_dirty_layers(
4133 &mut self,
4134 dpi_info: DpiInfo,
4135 dirty_layers: &[WidgetId],
4136 baseline_ime_composition_rect: Option<Rect>,
4137 text_system: Arc<TextSystem>,
4138 font_registry: Arc<FontRegistry>,
4139 image_registry: Arc<ImageRegistry>,
4140 ) -> PaintOutput {
4141 let mut scene = self
4142 .last_frame
4143 .as_ref()
4144 .map(|frame| frame.scene.clone())
4145 .unwrap_or_default();
4146 let mut images = Vec::new();
4147 let mut paint_bounds_by_widget = std::mem::take(&mut self.last_paint_bounds_by_widget);
4149 let mut ime_composition_rect = baseline_ime_composition_rect;
4150 let frame_time = self.frame_time();
4151
4152 for &widget_id in dirty_layers {
4153 let Some(bounds) = self
4154 .graph
4155 .node(widget_id)
4156 .map(|node| node.geometry.layout_bounds)
4157 else {
4158 return self.paint_full_scene(dpi_info, text_system, font_registry, image_registry);
4159 };
4160
4161 let mut paint_ctx = PaintCtx::new(
4162 self.id,
4163 widget_id,
4164 bounds,
4165 self.focus.focused_widget,
4166 dpi_info,
4167 Arc::clone(&text_system),
4168 Arc::clone(&font_registry),
4169 self.last_frame
4170 .as_ref()
4171 .map(|frame| Arc::clone(&frame.image_registry))
4172 .unwrap_or_else(|| Arc::clone(&image_registry)),
4173 )
4174 .with_frame_time(self.frame_time());
4175 paint_ctx.output_cache = output_cache::OutputCache::scope(&self.output_cache);
4176 if !self
4177 .root
4178 .paint_layer_contents_for(widget_id, &mut paint_ctx)
4179 {
4180 return self.paint_full_scene(dpi_info, text_system, font_registry, image_registry);
4181 }
4182
4183 let (layer_scene, layer_images, layer_paint_bounds, layer_ime_composition_rect) =
4184 paint_ctx.into_parts();
4185 let Some(descriptor) =
4186 self.root
4187 .layer_descriptor_for(widget_id, &layer_scene, frame_time)
4188 else {
4189 return self.paint_full_scene(dpi_info, text_system, font_registry, image_registry);
4190 };
4191 if widget_id == self.root.id()
4192 || !scene.replace_layer(
4193 widget_id,
4194 SceneLayer::from_descriptor(descriptor, layer_scene),
4195 )
4196 {
4197 return self.paint_full_scene(dpi_info, text_system, font_registry, image_registry);
4198 }
4199
4200 images.extend(layer_images);
4201 paint_bounds_by_widget.extend(layer_paint_bounds);
4202 if layer_ime_composition_rect.is_some() {
4203 ime_composition_rect = layer_ime_composition_rect;
4204 }
4205 }
4206
4207 (scene, images, paint_bounds_by_widget, ime_composition_rect)
4208 }
4209
4210 fn collect_dirty_layers(&self, invalidations: &[InvalidationRequest]) -> Vec<WidgetId> {
4211 let candidates: HashSet<WidgetId> = invalidations
4212 .iter()
4213 .filter(|request| {
4214 matches!(
4215 request.kind,
4216 InvalidationKind::Measure
4217 | InvalidationKind::Clip
4218 | InvalidationKind::Visibility
4219 | InvalidationKind::Paint
4220 | InvalidationKind::Text
4221 | InvalidationKind::Resources
4222 )
4223 })
4224 .map(|request| match request.target {
4225 InvalidationTarget::Widget(widget_id) if self.graph.contains(widget_id) => self
4226 .graph
4227 .nearest_paint_boundary_ancestor_or_root(widget_id),
4228 InvalidationTarget::Widget(_) => self.root.id(),
4229 InvalidationTarget::Window(_) | InvalidationTarget::Surface(_) => self.root.id(),
4230 })
4231 .collect();
4232
4233 if self.last_frame.is_none() || candidates.contains(&self.root.id()) {
4234 return vec![self.root.id()];
4235 }
4236
4237 let mut candidates: Vec<_> = candidates
4238 .into_iter()
4239 .filter(|widget_id| self.graph.contains(*widget_id))
4240 .collect();
4241 candidates.sort_by_key(|widget_id| {
4242 self.graph
4243 .path_to(*widget_id)
4244 .map_or(usize::MAX, |path| path.len())
4245 });
4246
4247 let mut minimized = Vec::new();
4248 for widget_id in candidates {
4249 if minimized
4250 .iter()
4251 .any(|ancestor| self.widget_is_ancestor_of(*ancestor, widget_id))
4252 {
4253 continue;
4254 }
4255 minimized.push(widget_id);
4256 }
4257
4258 minimized
4259 }
4260
4261 fn collect_graph_changes(&self, previous: Option<&WidgetGraph>) -> GraphChangeSet {
4262 let Some(previous) = previous else {
4263 return GraphChangeSet {
4264 output_widgets: vec![self.graph.root],
4265 repaint_widgets: vec![self.graph.root],
4266 transform_widgets: Vec::new(),
4267 };
4268 };
4269
4270 let previous_nodes = &previous.nodes;
4271 let current_nodes = &self.graph.nodes;
4272 let current_root = self.graph.root;
4273 let widget_ids = self.graph.order.iter().copied().chain(
4274 previous
4275 .order
4276 .iter()
4277 .copied()
4278 .filter(|widget_id| !current_nodes.contains_key(widget_id)),
4279 );
4280 let mut output_widgets = Vec::new();
4281 let mut repaint_candidates = HashSet::new();
4282 let mut transform_candidates = Vec::new();
4283
4284 for widget_id in widget_ids {
4285 match (
4286 previous_nodes.get(&widget_id),
4287 current_nodes.get(&widget_id),
4288 ) {
4289 (Some(previous_node), Some(current_node)) => {
4290 if previous_node.measured_size != current_node.measured_size
4291 || previous_node.geometry.layout_bounds.size
4292 != current_node.geometry.layout_bounds.size
4293 || previous_node.parent != current_node.parent
4294 || previous_node.children != current_node.children
4295 {
4296 output_widgets.push(current_node.id);
4297 repaint_candidates.insert(resolve_snapshot_paint_boundary_or_root(
4298 current_nodes,
4299 current_root,
4300 current_node.id,
4301 ));
4302 continue;
4303 }
4304
4305 let delta = current_node.geometry.layout_bounds.origin
4306 - previous_node.geometry.layout_bounds.origin;
4307 if delta != Vector::ZERO
4308 || previous_node.geometry.input_bounds != current_node.geometry.input_bounds
4309 {
4310 output_widgets.push(current_node.id);
4311 }
4312 if delta != Vector::ZERO {
4313 let resolved_boundary = resolve_snapshot_paint_boundary_or_root(
4314 current_nodes,
4315 current_root,
4316 current_node.id,
4317 );
4318 if resolved_boundary == current_node.id
4319 && current_node.paint_boundary == PaintBoundaryMode::Explicit
4320 {
4321 transform_candidates.push(LayerTranslation {
4322 widget_id: current_node.id,
4323 delta,
4324 });
4325 } else if current_nodes
4326 .get(&resolved_boundary)
4327 .zip(previous_nodes.get(&resolved_boundary))
4328 .is_some_and(|(current_boundary, previous_boundary)| {
4329 current_boundary.paint_boundary == PaintBoundaryMode::Explicit
4330 && same_layer_translation(
4331 current_boundary.geometry.layout_bounds.origin
4332 - previous_boundary.geometry.layout_bounds.origin,
4333 delta,
4334 )
4335 })
4336 {
4337 } else {
4342 repaint_candidates.insert(resolved_boundary);
4343 }
4344 }
4345 }
4346 (None, Some(current_node)) => {
4347 output_widgets.push(current_node.id);
4348 repaint_candidates.insert(resolve_snapshot_paint_boundary_or_root(
4349 current_nodes,
4350 current_root,
4351 current_node.id,
4352 ));
4353 }
4354 (Some(previous_node), None) => {
4355 repaint_candidates.insert(resolve_snapshot_paint_boundary_or_root(
4356 previous_nodes,
4357 previous.root,
4358 previous_node.id,
4359 ));
4360 }
4361 (None, None) => {}
4362 }
4363 }
4364
4365 let mut repaint_widgets = repaint_candidates.into_iter().collect::<Vec<_>>();
4366 repaint_widgets.sort_by_key(|widget_id| self.widget_depth(*widget_id));
4367 let mut minimized_repaint = Vec::new();
4368 for widget_id in repaint_widgets {
4369 if minimized_repaint
4370 .iter()
4371 .any(|ancestor| self.widget_is_ancestor_of(*ancestor, widget_id))
4372 {
4373 continue;
4374 }
4375 minimized_repaint.push(widget_id);
4376 }
4377
4378 transform_candidates.sort_by_key(|translation| self.widget_depth(translation.widget_id));
4379 let mut minimized_transforms = Vec::new();
4380 for candidate in transform_candidates {
4381 if minimized_repaint
4382 .iter()
4383 .any(|ancestor| self.widget_is_ancestor_of(*ancestor, candidate.widget_id))
4384 {
4385 continue;
4386 }
4387
4388 let inherited_delta = minimized_transforms
4389 .iter()
4390 .filter(|translation: &&LayerTranslation| {
4391 self.widget_is_ancestor_of(translation.widget_id, candidate.widget_id)
4392 })
4393 .fold(Vector::ZERO, |current, translation| {
4394 current + translation.delta
4395 });
4396 let residual = candidate.delta - inherited_delta;
4397 if residual == Vector::ZERO {
4398 continue;
4399 }
4400
4401 minimized_transforms.push(LayerTranslation {
4402 widget_id: candidate.widget_id,
4403 delta: residual,
4404 });
4405 }
4406
4407 GraphChangeSet {
4408 output_widgets,
4409 repaint_widgets: minimized_repaint,
4410 transform_widgets: minimized_transforms,
4411 }
4412 }
4413
4414 fn select_composition_only_transforms(
4415 &self,
4416 previous_scene: Option<&Scene>,
4417 transform_widgets: &[LayerTranslation],
4418 ) -> Vec<LayerTranslation> {
4419 let previous_layers = previous_scene.map(collect_scene_layers).unwrap_or_default();
4420 transform_widgets
4421 .iter()
4422 .copied()
4423 .filter(|translation| previous_layers.contains_key(&translation.widget_id))
4424 .collect()
4425 }
4426
4427 fn select_explicit_transform_translations(
4428 &self,
4429 previous_scene: Option<&Scene>,
4430 invalidations: &[InvalidationRequest],
4431 ) -> Vec<LayerTranslation> {
4432 let previous_layers = previous_scene.map(collect_scene_layers).unwrap_or_default();
4433 let mut translations = Vec::new();
4434
4435 for request in invalidations {
4436 if request.kind != InvalidationKind::Transform {
4437 continue;
4438 }
4439
4440 let InvalidationTarget::Widget(widget_id) = request.target else {
4441 continue;
4442 };
4443 let resolved_boundary = self
4444 .graph
4445 .nearest_paint_boundary_ancestor_or_root(widget_id);
4446 if resolved_boundary == self.root.id() {
4447 continue;
4448 }
4449 let Some(previous) = previous_layers.get(&resolved_boundary) else {
4450 continue;
4451 };
4452 let Some(current) = self.graph.node(resolved_boundary) else {
4453 continue;
4454 };
4455
4456 let delta = current.geometry.layout_bounds.origin - previous.bounds.origin;
4457 if delta == Vector::ZERO {
4458 continue;
4459 }
4460
4461 if translations
4462 .iter()
4463 .all(|translation: &LayerTranslation| translation.widget_id != resolved_boundary)
4464 {
4465 translations.push(LayerTranslation {
4466 widget_id: resolved_boundary,
4467 delta,
4468 });
4469 }
4470 }
4471
4472 translations
4473 }
4474
4475 fn collect_explicit_layer_descriptor_refreshes(
4476 &mut self,
4477 previous_scene: Option<&Scene>,
4478 invalidations: &[InvalidationRequest],
4479 ) -> Vec<LayerDescriptorRefresh> {
4480 let Some(previous_scene) = previous_scene else {
4481 return Vec::new();
4482 };
4483 if !invalidations.iter().any(|request| {
4484 matches!(
4485 request.kind,
4486 InvalidationKind::Transform | InvalidationKind::Effect
4487 )
4488 }) {
4489 return Vec::new();
4490 }
4491
4492 let previous_layers = collect_scene_layers(previous_scene);
4493 let mut refreshes = Vec::new();
4494 let frame_time = self.frame_time();
4495
4496 for (widget_id, previous_descriptor) in previous_layers {
4497 let Some(layer_scene) = previous_scene.layer_scene(widget_id).cloned() else {
4498 continue;
4499 };
4500 let Some(descriptor) =
4501 self.root
4502 .layer_descriptor_for(widget_id, &layer_scene, frame_time)
4503 else {
4504 continue;
4505 };
4506 if descriptor.properties == previous_descriptor.properties {
4507 continue;
4508 }
4509 refreshes.push(LayerDescriptorRefresh {
4510 widget_id,
4511 descriptor,
4512 });
4513 }
4514
4515 refreshes
4516 }
4517
4518 fn widget_depth(&self, widget_id: WidgetId) -> usize {
4519 self.graph.depth(widget_id).unwrap_or(usize::MAX)
4520 }
4521
4522 fn minimize_layer_roots(&self, candidates: &mut Vec<WidgetId>) {
4523 candidates.sort_by_key(|widget_id| (self.widget_depth(*widget_id), widget_id.get()));
4524 candidates.dedup();
4525 let mut minimized = Vec::with_capacity(candidates.len());
4526 for widget_id in candidates.iter().copied() {
4527 if minimized
4528 .iter()
4529 .any(|ancestor| self.widget_is_ancestor_of(*ancestor, widget_id))
4530 {
4531 continue;
4532 }
4533 minimized.push(widget_id);
4534 }
4535 *candidates = minimized;
4536 }
4537
4538 fn default_dirty_region_for_request(
4539 &self,
4540 viewport_rect: Rect,
4541 request: &InvalidationRequest,
4542 ) -> Rect {
4543 match request.target {
4544 InvalidationTarget::Widget(widget_id) => self
4545 .graph
4546 .node(widget_id)
4547 .map(|node| node.geometry.paint_bounds)
4548 .unwrap_or(viewport_rect),
4549 InvalidationTarget::Window(_) | InvalidationTarget::Surface(_) => viewport_rect,
4550 }
4551 }
4552
4553 fn collect_layer_updates(
4554 &self,
4555 previous_scene: Option<&Scene>,
4556 scene: &Scene,
4557 invalidations: &[InvalidationRequest],
4558 dirty_layers: &[WidgetId],
4559 graph_dirty_widgets: &[WidgetId],
4560 ) -> Vec<SceneLayerUpdate> {
4561 let current_layers = collect_scene_layers(scene);
4562 if current_layers.is_empty() {
4563 return Vec::new();
4564 }
4565
4566 let previous_layers = previous_scene.map(collect_scene_layers).unwrap_or_default();
4567 let mut updates = HashMap::<WidgetId, SceneLayerUpdateKind>::new();
4568 let mut damage_regions = HashMap::<WidgetId, Rect>::new();
4569 let explicit_transform_widgets = invalidations
4570 .iter()
4571 .filter_map(|request| {
4572 if request.kind != InvalidationKind::Transform {
4573 return None;
4574 }
4575
4576 match request.target {
4577 InvalidationTarget::Widget(widget_id) if self.graph.contains(widget_id) => {
4578 Some(
4579 self.graph
4580 .nearest_paint_boundary_ancestor_or_root(widget_id),
4581 )
4582 }
4583 _ => None,
4584 }
4585 })
4586 .collect::<HashSet<_>>();
4587
4588 for request in invalidations {
4589 let Some(kind) = invalidation_to_layer_update_kind(request.kind) else {
4590 continue;
4591 };
4592 let widget_id = match request.target {
4593 InvalidationTarget::Widget(widget_id) if self.graph.contains(widget_id) => self
4594 .graph
4595 .nearest_paint_boundary_ancestor_or_root(widget_id),
4596 InvalidationTarget::Widget(_) => self.root.id(),
4597 InvalidationTarget::Window(_) | InvalidationTarget::Surface(_) => self.root.id(),
4598 };
4599 if request.kind == InvalidationKind::Arrange
4600 && explicit_transform_widgets
4601 .iter()
4602 .any(|candidate| self.widget_is_ancestor_of(widget_id, *candidate))
4603 {
4604 continue;
4605 }
4606 merge_layer_update_kind(&mut updates, widget_id, kind);
4607 if let Some(region) = request.region {
4608 damage_regions
4609 .entry(widget_id)
4610 .and_modify(|current| *current = current.union(region))
4611 .or_insert(region);
4612 }
4613 }
4614
4615 for (widget_id, descriptor) in ¤t_layers {
4616 let Some(previous) = previous_layers.get(widget_id) else {
4617 merge_layer_update_kind(&mut updates, *widget_id, SceneLayerUpdateKind::Content);
4618 continue;
4619 };
4620 if descriptor.stack_host != previous.stack_host
4621 || descriptor.stack_order != previous.stack_order
4622 || descriptor.transient_owner_surface != previous.transient_owner_surface
4623 || descriptor.is_stack_surface != previous.is_stack_surface
4624 {
4625 merge_layer_update_kind(&mut updates, *widget_id, SceneLayerUpdateKind::Ordering);
4626 }
4627 if descriptor.properties.translation != previous.properties.translation
4628 || descriptor.properties.scale != previous.properties.scale
4629 || descriptor.properties.scale_anchor != previous.properties.scale_anchor
4630 {
4631 merge_layer_update_kind(&mut updates, *widget_id, SceneLayerUpdateKind::Transform);
4632 }
4633 if descriptor.properties.opacity != previous.properties.opacity {
4634 merge_layer_update_kind(&mut updates, *widget_id, SceneLayerUpdateKind::Effect);
4635 }
4636 }
4637
4638 for widget_id in graph_dirty_widgets.iter().copied() {
4639 merge_layer_update_kind(&mut updates, widget_id, SceneLayerUpdateKind::Transform);
4640 }
4641
4642 for widget_id in dirty_layers.iter().copied() {
4643 merge_layer_update_kind(&mut updates, widget_id, SceneLayerUpdateKind::Content);
4644 }
4645
4646 let mut resolved_updates = Vec::new();
4647 for (widget_id, kind) in updates {
4648 let Some(descriptor) = current_layers.get(&widget_id).cloned() else {
4649 continue;
4650 };
4651 let fallback_damage = previous_layers
4652 .get(&widget_id)
4653 .map(|previous| {
4654 previous
4655 .presented_paint_bounds()
4656 .union(descriptor.presented_paint_bounds())
4657 })
4658 .unwrap_or(descriptor.presented_paint_bounds());
4659 let damage = damage_regions
4660 .get(&widget_id)
4661 .copied()
4662 .unwrap_or(fallback_damage);
4663 resolved_updates
4664 .push(SceneLayerUpdate::from_descriptor(kind, descriptor).with_damage(damage));
4665 }
4666
4667 resolved_updates.sort_by_key(|update| update.owner.get());
4668 resolved_updates
4669 }
4670
4671 fn widget_is_ancestor_of(&self, ancestor: WidgetId, widget_id: WidgetId) -> bool {
4672 self.graph.is_ancestor_of(ancestor, widget_id)
4673 }
4674
4675 fn build_measure_scope(&self, invalidations: &[InvalidationRequest]) -> Rc<MeasureScope> {
4684 let mut subtree_roots: HashSet<WidgetId> = HashSet::new();
4685 let mut force_all = false;
4686 for request in invalidations {
4687 if !matches!(
4688 request.kind,
4689 InvalidationKind::Measure
4690 | InvalidationKind::Text
4691 | InvalidationKind::Visibility
4692 | InvalidationKind::Ordering
4693 ) {
4694 continue;
4695 }
4696 match request.target {
4697 InvalidationTarget::Widget(widget_id) => {
4698 subtree_roots.insert(widget_id);
4699 }
4700 InvalidationTarget::Window(_) | InvalidationTarget::Surface(_) => {
4701 force_all = true;
4702 }
4703 }
4704 }
4705
4706 if force_all || subtree_roots.is_empty() {
4707 return Rc::new(MeasureScope::force_all());
4708 }
4709
4710 let mut dirty: HashSet<WidgetId> = HashSet::new();
4711 for widget_id in &subtree_roots {
4712 if !self.graph.extend_ancestors(*widget_id, &mut dirty) {
4713 return Rc::new(MeasureScope::force_all());
4714 }
4715 }
4716
4717 Rc::new(MeasureScope::scoped(dirty, subtree_roots))
4718 }
4719
4720 fn build_arrange_scope(&self, invalidations: &[InvalidationRequest]) -> Rc<ArrangeScope> {
4721 let mut subtree_roots: HashSet<WidgetId> = HashSet::new();
4722 let mut force_all = false;
4723 for request in invalidations {
4724 if !matches!(
4725 request.kind,
4726 InvalidationKind::Measure
4727 | InvalidationKind::Arrange
4728 | InvalidationKind::Transform
4729 | InvalidationKind::Clip
4730 | InvalidationKind::Visibility
4731 | InvalidationKind::Text
4732 ) {
4733 continue;
4734 }
4735 match request.target {
4736 InvalidationTarget::Widget(widget_id) => {
4737 subtree_roots.insert(widget_id);
4738 }
4739 InvalidationTarget::Window(_) | InvalidationTarget::Surface(_) => {
4740 force_all = true;
4741 }
4742 }
4743 }
4744
4745 if force_all || subtree_roots.is_empty() {
4746 return Rc::new(ArrangeScope::force_all());
4747 }
4748
4749 let mut dirty: HashSet<WidgetId> = HashSet::new();
4750 for widget_id in subtree_roots {
4751 if !self.graph.extend_ancestors(widget_id, &mut dirty) {
4752 return Rc::new(ArrangeScope::force_all());
4753 }
4754 }
4755 Rc::new(ArrangeScope::scoped(dirty))
4756 }
4757
4758 fn run_measure_arrange_pass(
4759 &mut self,
4760 invalidations: &[InvalidationRequest],
4761 text_system: Arc<TextSystem>,
4762 font_registry: Arc<FontRegistry>,
4763 image_registry: Arc<ImageRegistry>,
4764 ) -> Vec<InvalidationRequest> {
4765 let constraints = self.measure_constraints();
4766 let scope = self.build_measure_scope(invalidations);
4767 if (self.schedule.measure || self.viewport.is_none()) && scope.is_full_invalidation() {
4768 self.measure_queries.borrow_mut().invalidate_context();
4769 }
4770 let mut measure_ctx = MeasureCtx::new_scoped_at(
4771 self.id,
4772 self.root.id(),
4773 self.root.bounds(),
4774 self.current_dpi_info(),
4775 text_system,
4776 font_registry,
4777 image_registry,
4778 scope,
4779 self.frame_time(),
4780 );
4781 measure_ctx.set_query_cache(self.measure_queries.clone());
4782 layout_work::record(|work| work.layout_passes += 1);
4783 let measure_started = layout_work::started();
4784 let measured_root = if self.schedule.measure || self.viewport.is_none() {
4785 self.root.measure(&mut measure_ctx, constraints)
4786 } else {
4787 self.root.measured_size()
4788 };
4789
4790 layout_work::elapsed(measure_started, |work, us| work.measure_us += us);
4791 let viewport = constraints.clamp(measured_root);
4792
4793 let mut pass_invalidations = measure_ctx.take_invalidations();
4794 let mut arrange_invalidations = invalidations.to_vec();
4795 arrange_invalidations.extend(pass_invalidations.iter().cloned());
4796 let arrange_scope = self.build_arrange_scope(&arrange_invalidations);
4797 let mut arrange_ctx = ArrangeCtx::new_scoped_at(
4798 self.id,
4799 self.root.id(),
4800 self.current_dpi_info(),
4801 self.frame_time(),
4802 arrange_scope,
4803 );
4804 let arrange_started = layout_work::started();
4805 self.root.arrange(
4806 &mut arrange_ctx,
4807 Rect::from_origin_size(Point::ZERO, viewport),
4808 );
4809
4810 layout_work::elapsed(arrange_started, |work, us| work.arrange_us += us);
4811 self.viewport = Some(viewport);
4812 self.schedule.measure = false;
4813 self.schedule.arrange = false;
4814 self.schedule.hit_test = false;
4815 self.refresh_graph();
4816
4817 let mut invalidations = std::mem::take(&mut pass_invalidations);
4818 self.apply_wake_requests(measure_ctx.take_wake_requests());
4819 invalidations.extend(arrange_ctx.take_invalidations());
4820 self.apply_wake_requests(arrange_ctx.take_wake_requests());
4821 invalidations
4822 }
4823
4824 fn refresh_graph(&mut self) {
4825 let graph_started = layout_work::started();
4826 if !self.previous_graph_saved && !self.graph.is_empty() {
4827 std::mem::swap(&mut self.graph, &mut self.previous_graph);
4828 self.previous_graph_saved = true;
4829 }
4830 self.graph.rebuild_in_place(
4831 &self.root,
4832 self.focus.focused_widget,
4833 &self.last_paint_bounds_by_widget,
4834 );
4835
4836 let overlay_focus = self.overlay_manager.sync(
4837 self.graph.overlay_snapshots(),
4838 &self.graph,
4839 self.focus.focused_widget,
4840 );
4841 if overlay_focus.is_some() {
4842 self.pending_overlay_focus = overlay_focus;
4843 }
4844 self.prune_runtime_state();
4845 self.schedule.hit_test = false;
4846 layout_work::elapsed(graph_started, |work, us| work.graph_us += us);
4847 }
4848
4849 fn filter_modal_semantics(&self, mut nodes: Vec<SemanticsNode>) -> Vec<SemanticsNode> {
4850 let Some(modal) = self.overlay_manager.active_modal() else {
4851 return nodes;
4852 };
4853
4854 let modal_subtree = self
4855 .graph
4856 .subtree_ids(modal)
4857 .into_iter()
4858 .collect::<HashSet<_>>();
4859 let mut allowed = modal_subtree.clone();
4860 let mut ancestor = self.graph.node(modal).and_then(|node| node.parent);
4861 while let Some(widget_id) = ancestor {
4862 allowed.insert(widget_id);
4863 ancestor = self.graph.node(widget_id).and_then(|node| node.parent);
4864 }
4865
4866 let parents = nodes
4867 .iter()
4868 .map(|node| (node.id, node.parent))
4869 .collect::<HashMap<_, _>>();
4870 let belongs_to_modal = |node: &SemanticsNode| {
4871 if allowed.contains(&node.id) {
4872 return true;
4873 }
4874 let mut current = node.parent;
4875 let mut visited = HashSet::new();
4876 while let Some(parent) = current {
4877 if !visited.insert(parent) {
4878 break;
4879 }
4880 if modal_subtree.contains(&parent) {
4881 return true;
4882 }
4883 current = parents.get(&parent).copied().flatten();
4884 }
4885 false
4886 };
4887 nodes.retain(belongs_to_modal);
4888 if let Some(node) = nodes.iter_mut().find(|node| node.id == modal) {
4889 node.state.modal = true;
4890 }
4891 nodes
4892 }
4893
4894 fn sync_scene_stack_metadata(&self, scene: &mut Scene) {
4895 if self.scene_stack_metadata_is_current(scene) {
4898 return;
4899 }
4900 scene.visit_layers_mut(&mut |layer| {
4901 if let Some(node) = self.graph.node(layer.widget_id()) {
4902 layer.descriptor.stack_host = node.stack_host;
4903 layer.descriptor.stack_order = node.stack_surface_order;
4904 layer.descriptor.transient_owner_surface = node.transient_owner_surface;
4905 layer.descriptor.is_stack_surface = node.is_stack_surface;
4906 layer.descriptor.hit_test = node.hit_test;
4907 }
4908 });
4909 scene.reorder_stack_surfaces();
4910 }
4911
4912 fn scene_stack_metadata_is_current(&self, scene: &Scene) -> bool {
4915 let mut last_stack_order = None;
4916 for command in scene.commands() {
4917 let SceneCommand::Layer(layer) = command else {
4918 continue;
4919 };
4920 if let Some(node) = self.graph.node(layer.widget_id()) {
4921 let descriptor = &layer.descriptor;
4922 if descriptor.stack_host != node.stack_host
4923 || descriptor.stack_order != node.stack_surface_order
4924 || descriptor.transient_owner_surface != node.transient_owner_surface
4925 || descriptor.is_stack_surface != node.is_stack_surface
4926 || descriptor.hit_test != node.hit_test
4927 {
4928 return false;
4929 }
4930 }
4931 if layer.descriptor.is_stack_surface {
4932 let order = layer.descriptor.stack_order;
4933 if last_stack_order.is_some_and(|last| order < last) {
4934 return false;
4935 }
4936 last_stack_order = Some(order);
4937 }
4938 if !self.scene_stack_metadata_is_current(&layer.scene) {
4939 return false;
4940 }
4941 }
4942 true
4943 }
4944
4945 fn prune_runtime_state(&mut self) {
4946 self.pointer_capture
4947 .retain(|_, widget_id| self.graph.is_live(*widget_id));
4948 let stale_grab_owner = self
4949 .cursor
4950 .grab_owner
4951 .is_some_and(|widget_id| !self.graph.is_live(widget_id));
4952 let stale_visibility_owner = self
4953 .cursor
4954 .visibility_owner
4955 .is_some_and(|widget_id| !self.graph.is_live(widget_id));
4956 if stale_grab_owner || stale_visibility_owner {
4957 self.reset_cursor_state();
4958 }
4959 if self
4960 .active_drag
4961 .as_ref()
4962 .is_some_and(|drag| !self.graph.is_live(drag.source))
4963 {
4964 self.active_drag = None;
4965 }
4966 self.scheduled_timers
4967 .retain(|timer| self.graph.contains(timer.target));
4968 self.delivering_timers
4969 .retain(|_, widget_id| self.graph.contains(*widget_id));
4970 self.async_wake_targets
4971 .retain(|_, widget_id| self.graph.contains(*widget_id));
4972 self.pending_async_wakeups
4973 .retain(|token| self.async_wake_targets.contains_key(token));
4974 self.requested_animation_frames
4975 .retain(|widget_id| self.graph.contains(*widget_id));
4976 self.delivering_animation_frames
4977 .retain(|widget_id| self.graph.contains(*widget_id));
4978 self.active_motions
4979 .retain(|(widget_id, _), _| self.graph.contains(*widget_id));
4980 self.motion_ends
4981 .retain(|(widget_id, _), _| self.graph.contains(*widget_id));
4982 if self.delivering_animation_frames.is_empty() && !self.wants_animation_frame() {
4983 self.last_animation_frame_time = None;
4984 }
4985
4986 if self
4987 .focus
4988 .focused_widget
4989 .is_some_and(|widget_id| !self.graph.is_live(widget_id))
4990 {
4991 self.focus.focused_widget = None;
4992 self.focused_semantics = None;
4993 }
4994 }
4995
4996 fn measure_constraints(&self) -> Constraints {
4997 self.viewport_hint
4998 .map(Constraints::tight)
4999 .unwrap_or(Constraints::UNBOUNDED)
5000 }
5001
5002 fn dpi_info_for_viewport(&self, viewport: Size) -> DpiInfo {
5003 DpiInfo::new(
5004 self.scale_factor,
5005 self.raw_dpi,
5006 viewport,
5007 scale_viewport_to_surface_size(viewport, self.scale_factor),
5008 )
5009 .with_safe_area(self.safe_area)
5010 }
5011
5012 fn current_dpi_info(&self) -> DpiInfo {
5013 let viewport = self.viewport_hint.or(self.viewport).unwrap_or(Size::ZERO);
5019 self.dpi_info_for_viewport(viewport)
5020 }
5021
5022 fn clear_inspector_history(&mut self) {
5023 self.event_route_history.clear();
5024 self.reactive_invalidation_history.clear();
5025 self.command_dispatch_history.clear();
5026 self.invalidation_history.clear();
5027 self.widget_rebuild_history.clear();
5028 }
5029
5030 fn capture_inspector_diagnostics(&mut self, diagnostics: &RenderDiagnostics) {
5031 if !self.inspector_tracing_enabled {
5032 return;
5033 }
5034
5035 extend_inspector_history(
5036 &mut self.reactive_invalidation_history,
5037 diagnostics.reactive_invalidations.iter().cloned(),
5038 );
5039 extend_inspector_history(
5040 &mut self.command_dispatch_history,
5041 diagnostics.command_dispatches.iter().cloned(),
5042 );
5043 extend_inspector_history(
5044 &mut self.invalidation_history,
5045 diagnostics.invalidations.iter().cloned(),
5046 );
5047 extend_inspector_history(
5048 &mut self.widget_rebuild_history,
5049 diagnostics.widget_rebuilds.iter().cloned(),
5050 );
5051 self.last_render_diagnostics = diagnostics.clone();
5052 }
5053
5054 fn scheduler_snapshot(&self) -> SchedulerInspectorSnapshot {
5055 let mut timers = self
5056 .scheduled_timers
5057 .iter()
5058 .map(|timer| TimerInspectorSnapshot {
5059 token: timer.token,
5060 target: timer.target,
5061 deadline: timer.deadline,
5062 delivering: self.delivering_timers.contains_key(&timer.token),
5063 })
5064 .collect::<Vec<_>>();
5065 for (&token, &target) in &self.delivering_timers {
5066 if timers.iter().all(|timer| timer.token != token) {
5067 timers.push(TimerInspectorSnapshot {
5068 token,
5069 target,
5070 deadline: self.last_tick_time,
5071 delivering: true,
5072 });
5073 }
5074 }
5075 timers.sort_by(|left, right| left.deadline.total_cmp(&right.deadline));
5076
5077 let mut async_tasks = self
5078 .async_wake_targets
5079 .iter()
5080 .map(|(&token, &target)| AsyncTaskInspectorSnapshot {
5081 token,
5082 target,
5083 pending_wake: self.pending_async_wakeups.contains(&token),
5084 })
5085 .collect::<Vec<_>>();
5086 async_tasks.sort_by_key(|task| task.token.get());
5087
5088 SchedulerInspectorSnapshot {
5089 timers,
5090 async_tasks,
5091 requested_animation_frames: self.requested_animation_frames.iter().copied().collect(),
5092 delivering_animation_frames: self.delivering_animation_frames.iter().copied().collect(),
5093 last_animation_frame_time: self.last_animation_frame_time,
5094 }
5095 }
5096
5097 fn inspector_snapshot(&self) -> WindowInspectorSnapshot {
5098 let mut widget_diagnostics = Vec::new();
5099 self.root.collect_diagnostics(&mut widget_diagnostics);
5100 WindowInspectorSnapshot {
5101 window_id: self.id,
5102 title: self.title.clone(),
5103 tracing_enabled: self.inspector_tracing_enabled,
5104 focus_state: self.focus,
5105 schedule: self.schedule,
5106 semantics: self.last_semantics.clone(),
5107 widget_graph: self.graph.snapshot(),
5108 overlays: self.overlay_manager.snapshot(),
5109 scheduler: self.scheduler_snapshot(),
5110 widget_diagnostics,
5111 last_render_diagnostics: self.last_render_diagnostics.clone(),
5112 history: InspectorHistorySnapshot {
5113 event_routes: self.event_route_history.iter().cloned().collect(),
5114 reactive_invalidations: self
5115 .reactive_invalidation_history
5116 .iter()
5117 .cloned()
5118 .collect(),
5119 command_dispatches: self.command_dispatch_history.iter().cloned().collect(),
5120 invalidations: self.invalidation_history.iter().cloned().collect(),
5121 widget_rebuilds: self.widget_rebuild_history.iter().cloned().collect(),
5122 },
5123 scene: self.last_frame.as_ref().map(|frame| {
5124 SceneStatistics::from_frame_with_mode(
5125 frame,
5126 self.graph.nodes.len(),
5127 window_scene_statistics_detail_mode(self.id),
5128 )
5129 }),
5130 }
5131 }
5132}
5133
5134impl Drop for WindowState {
5135 fn drop(&mut self) {
5136 self.output_cache.borrow_mut().close();
5137 reactive::unregister_window(self.id);
5138 diagnostics::clear_widget_rebuilds(self.id);
5139 }
5140}
5141
5142fn normalize_scale_factor(scale_factor: f32) -> f32 {
5143 if scale_factor.is_finite() && scale_factor > 0.0 {
5144 scale_factor
5145 } else {
5146 1.0
5147 }
5148}
5149
5150fn scale_viewport_to_surface_size(viewport: Size, scale_factor: f32) -> Size {
5151 if viewport.is_empty() {
5152 return Size::ZERO;
5153 }
5154
5155 let scale_factor = normalize_scale_factor(scale_factor);
5156 Size::new(
5157 (viewport.width * scale_factor).round().max(1.0),
5158 (viewport.height * scale_factor).round().max(1.0),
5159 )
5160}
5161
5162impl WindowState {
5163 fn assemble_semantics_tree(&mut self, nodes: Vec<SemanticsNode>) -> Vec<SemanticsNode> {
5164 let semantic_ids: FxHashSet<_> = nodes.iter().map(|node| node.id).collect();
5165 if self
5166 .focused_semantics
5167 .is_some_and(|focused| !semantic_ids.contains(&focused))
5168 {
5169 self.focused_semantics = self.focus.focused_widget;
5170 }
5171
5172 nodes
5173 .into_iter()
5174 .map(|mut node| {
5175 node.parent = self.resolve_semantics_parent(&semantic_ids, node.id, node.parent);
5176 node.state.focused |= Some(node.id) == self.focused_semantics;
5177 node
5178 })
5179 .collect()
5180 }
5181
5182 fn resolve_semantics_parent(
5183 &self,
5184 semantic_ids: &FxHashSet<WidgetId>,
5185 widget_id: WidgetId,
5186 explicit_parent: Option<WidgetId>,
5187 ) -> Option<WidgetId> {
5188 if let Some(parent) =
5189 explicit_parent.filter(|parent| *parent != widget_id && semantic_ids.contains(parent))
5190 {
5191 return Some(parent);
5192 }
5193
5194 let mut current = self.graph.node(widget_id).and_then(|node| node.parent);
5195 while let Some(candidate) = current {
5196 if semantic_ids.contains(&candidate) {
5197 return Some(candidate);
5198 }
5199 current = self.graph.node(candidate).and_then(|node| node.parent);
5200 }
5201 None
5202 }
5203}
5204
5205#[derive(Default)]
5206struct WidgetGraph {
5207 root: WidgetId,
5208 nodes: FxHashMap<WidgetId, WidgetNodeSnapshot>,
5209 order: Vec<WidgetId>,
5210 host_surface_order: FxHashMap<WidgetId, Vec<WidgetId>>,
5211 host_order_policy: FxHashMap<WidgetId, StackOrderPolicy>,
5212 overlay_options: FxHashMap<WidgetId, OverlayOptions>,
5213 overlay_parents: FxHashMap<WidgetId, Option<WidgetId>>,
5214 overlay_surfaces: FxHashMap<WidgetId, Vec<WidgetId>>,
5215 child_buffers: Vec<Vec<WidgetId>>,
5216}
5217
5218#[derive(Clone, Copy)]
5219struct GraphCollectContext {
5220 stack_host: WidgetId,
5221 stack_surface: WidgetId,
5222 overlay_owner: Option<WidgetId>,
5223 inert: bool,
5224}
5225
5226impl WidgetGraph {
5227 fn empty(root: WidgetId) -> Self {
5228 Self {
5229 root,
5230 nodes: FxHashMap::default(),
5231 order: Vec::new(),
5232 host_surface_order: FxHashMap::default(),
5233 host_order_policy: FxHashMap::default(),
5234 overlay_options: FxHashMap::default(),
5235 overlay_parents: FxHashMap::default(),
5236 overlay_surfaces: FxHashMap::default(),
5237 child_buffers: Vec::new(),
5238 }
5239 }
5240
5241 fn rebuild_in_place(
5242 &mut self,
5243 root: &WidgetPod,
5244 focused_widget: Option<WidgetId>,
5245 paint_bounds_by_widget: &FxHashMap<WidgetId, Rect>,
5246 ) {
5247 self.root = root.id();
5248 for (_, mut node) in self.nodes.drain() {
5249 node.children.clear();
5250 self.child_buffers.push(node.children);
5251 }
5252 self.order.clear();
5253 self.host_surface_order.clear();
5254 self.host_order_policy.clear();
5255 self.overlay_options.clear();
5256 self.overlay_parents.clear();
5257 self.overlay_surfaces.clear();
5258 let mut inverse_cache = FxHashMap::default();
5259 self.collect(
5260 root,
5261 None,
5262 focused_widget,
5263 paint_bounds_by_widget,
5264 GraphCollectContext {
5265 stack_host: root.id(),
5266 stack_surface: root.id(),
5267 overlay_owner: None,
5268 inert: false,
5269 },
5270 &mut inverse_cache,
5271 );
5272 self.recompute_stack_surface_order();
5273 }
5274
5275 fn recompute_stack_surface_order(&mut self) {
5276 let mut position_by_surface = HashMap::<(WidgetId, WidgetId), usize>::new();
5277 for (host, surfaces) in &self.host_surface_order {
5278 for (index, surface) in surfaces.iter().copied().enumerate() {
5279 position_by_surface.insert((*host, surface), index);
5280 }
5281 }
5282
5283 for node in self.nodes.values_mut() {
5284 if let Some(order) = position_by_surface.get(&(node.stack_host, node.stack_surface)) {
5285 node.stack_surface_order = *order;
5286 }
5287 }
5288 }
5289
5290 fn update_paint_bounds_from_snapshot(
5291 &mut self,
5292 paint_bounds_by_widget: &FxHashMap<WidgetId, Rect>,
5293 ) {
5294 for node in self.nodes.values_mut() {
5295 node.geometry.paint_bounds = paint_bounds_by_widget
5296 .get(&node.id)
5297 .copied()
5298 .unwrap_or(node.geometry.layout_bounds);
5299 }
5300 }
5301
5302 fn set_focused_widget(&mut self, focused_widget: Option<WidgetId>) {
5303 for node in self.nodes.values_mut() {
5304 node.focused = Some(node.id) == focused_widget;
5305 }
5306 }
5307
5308 fn is_empty(&self) -> bool {
5309 self.nodes.is_empty()
5310 }
5311
5312 fn contains(&self, widget_id: WidgetId) -> bool {
5313 self.nodes.contains_key(&widget_id)
5314 }
5315
5316 fn is_live(&self, widget_id: WidgetId) -> bool {
5319 self.nodes.get(&widget_id).is_some_and(|node| !node.inert)
5320 }
5321
5322 fn node(&self, widget_id: WidgetId) -> Option<&WidgetNodeSnapshot> {
5323 self.nodes.get(&widget_id)
5324 }
5325
5326 fn snapshot(&self) -> WidgetGraphSnapshot {
5327 let mut stack_hosts = self
5328 .host_order_policy
5329 .iter()
5330 .map(|(host, order_policy)| StackHostSnapshot {
5331 host: *host,
5332 order_policy: *order_policy,
5333 surfaces: self
5334 .host_surface_order
5335 .get(host)
5336 .cloned()
5337 .unwrap_or_default(),
5338 })
5339 .collect::<Vec<_>>();
5340 stack_hosts.sort_by_key(|host| host.host.get());
5341
5342 WidgetGraphSnapshot {
5343 root: self.root,
5344 nodes: self
5345 .order
5346 .iter()
5347 .filter_map(|widget_id| self.nodes.get(widget_id).cloned())
5348 .collect(),
5349 stack_hosts,
5350 }
5351 }
5352
5353 fn hit_test(&self, point: Point) -> Option<WidgetId> {
5354 self.hit_test_node(self.root, point)
5355 }
5356
5357 fn hit_test_within(&self, widget_id: WidgetId, point: Point) -> Option<WidgetId> {
5358 self.hit_test_node(widget_id, point)
5359 }
5360
5361 fn path_to(&self, target: WidgetId) -> Option<Vec<WidgetId>> {
5362 let mut path = Vec::new();
5363 let mut current = Some(target);
5364
5365 while let Some(widget_id) = current {
5366 let node = self.node(widget_id)?;
5367 path.push(widget_id);
5368 current = node.parent;
5369 }
5370
5371 path.reverse();
5372 Some(path)
5373 }
5374
5375 fn depth(&self, target: WidgetId) -> Option<usize> {
5376 let mut depth = 0usize;
5377 let mut current = Some(target);
5378 while let Some(widget_id) = current {
5379 let node = self.node(widget_id)?;
5380 depth += 1;
5381 current = node.parent;
5382 }
5383 Some(depth)
5384 }
5385
5386 fn is_ancestor_of(&self, ancestor: WidgetId, target: WidgetId) -> bool {
5387 let mut current = self.node(target).and_then(|node| node.parent);
5388 while let Some(widget_id) = current {
5389 if widget_id == ancestor {
5390 return true;
5391 }
5392 current = self.node(widget_id).and_then(|node| node.parent);
5393 }
5394 false
5395 }
5396
5397 fn extend_ancestors(&self, target: WidgetId, ancestors: &mut HashSet<WidgetId>) -> bool {
5398 let mut current = Some(target);
5399 while let Some(widget_id) = current {
5400 let Some(node) = self.node(widget_id) else {
5401 return false;
5402 };
5403 ancestors.insert(widget_id);
5404 current = node.parent;
5405 }
5406 true
5407 }
5408
5409 fn subtree_ids(&self, root: WidgetId) -> Vec<WidgetId> {
5410 let mut subtree = Vec::new();
5411 let mut pending = vec![root];
5412 while let Some(widget_id) = pending.pop() {
5413 let Some(node) = self.node(widget_id) else {
5414 continue;
5415 };
5416 subtree.push(widget_id);
5417 pending.extend(node.children.iter().copied());
5418 }
5419 subtree
5420 }
5421
5422 fn nearest_paint_boundary_ancestor_or_root(&self, widget_id: WidgetId) -> WidgetId {
5423 let mut current = Some(widget_id);
5424 while let Some(candidate) = current {
5425 let Some(node) = self.node(candidate) else {
5426 break;
5427 };
5428 if node.paint_boundary == PaintBoundaryMode::Explicit {
5429 return candidate;
5430 }
5431 current = node.parent;
5432 }
5433 self.root
5434 }
5435
5436 fn next_focusable(&self, current: Option<WidgetId>, backwards: bool) -> Option<WidgetId> {
5437 let focusable: Vec<_> = self
5438 .order
5439 .iter()
5440 .copied()
5441 .filter(|widget_id| self.node(*widget_id).is_some_and(|node| node.accepts_focus))
5442 .collect();
5443
5444 if focusable.is_empty() {
5445 return None;
5446 }
5447
5448 let fallback = if backwards {
5449 focusable.last().copied()
5450 } else {
5451 focusable.first().copied()
5452 };
5453
5454 let Some(current) = current else {
5455 return fallback;
5456 };
5457
5458 let Some(index) = focusable.iter().position(|widget_id| *widget_id == current) else {
5459 return fallback;
5460 };
5461
5462 if backwards {
5463 Some(focusable[(index + focusable.len() - 1) % focusable.len()])
5464 } else {
5465 Some(focusable[(index + 1) % focusable.len()])
5466 }
5467 }
5468
5469 fn first_focusable_within(
5470 &self,
5471 overlay_owner: WidgetId,
5472 include_owner: bool,
5473 ) -> Option<WidgetId> {
5474 self.order.iter().copied().find(|candidate| {
5475 self.node(*candidate).is_some_and(|node| node.accepts_focus)
5476 && (include_owner && *candidate == overlay_owner
5477 || self.is_ancestor_of(overlay_owner, *candidate))
5478 })
5479 }
5480
5481 fn next_focusable_within(
5482 &self,
5483 scope: WidgetId,
5484 current: Option<WidgetId>,
5485 backwards: bool,
5486 ) -> Option<WidgetId> {
5487 let focusable = self
5488 .order
5489 .iter()
5490 .copied()
5491 .filter(|candidate| {
5492 self.node(*candidate).is_some_and(|node| node.accepts_focus)
5493 && (*candidate == scope || self.is_ancestor_of(scope, *candidate))
5494 })
5495 .collect::<Vec<_>>();
5496 if focusable.is_empty() {
5497 return None;
5498 }
5499 let fallback = if backwards {
5500 focusable.last().copied()
5501 } else {
5502 focusable.first().copied()
5503 };
5504 let Some(current) = current else {
5505 return fallback;
5506 };
5507 let Some(index) = focusable.iter().position(|candidate| *candidate == current) else {
5508 return fallback;
5509 };
5510 if backwards {
5511 Some(focusable[(index + focusable.len() - 1) % focusable.len()])
5512 } else {
5513 Some(focusable[(index + 1) % focusable.len()])
5514 }
5515 }
5516
5517 fn overlay_snapshots(&self) -> Vec<OverlaySnapshot> {
5518 self.order
5519 .iter()
5520 .copied()
5521 .filter_map(|owner| {
5522 let options = self.overlay_options.get(&owner).copied()?;
5523 Some(OverlaySnapshot {
5524 owner,
5525 parent: self.overlay_parents.get(&owner).copied().flatten(),
5526 surfaces: self
5527 .overlay_surfaces
5528 .get(&owner)
5529 .cloned()
5530 .unwrap_or_default(),
5531 options,
5532 order: 0,
5533 })
5534 })
5535 .enumerate()
5536 .map(|(order, mut snapshot)| {
5537 snapshot.order = order;
5538 snapshot
5539 })
5540 .collect()
5541 }
5542
5543 fn collect(
5544 &mut self,
5545 pod: &WidgetPod,
5546 parent: Option<WidgetId>,
5547 focused_widget: Option<WidgetId>,
5548 paint_bounds_by_widget: &FxHashMap<WidgetId, Rect>,
5549 context: GraphCollectContext,
5550 inverse_cache: &mut FxHashMap<[u32; 6], Option<Transform>>,
5551 ) {
5552 let id = pod.id();
5553 self.order.push(id);
5554 let inert = context.inert || pod.is_inert();
5555
5556 let overlay_options = pod.current_overlay_options();
5557 let is_overlay_owner = overlay_options.is_some();
5558 let overlay_owner = if is_overlay_owner {
5559 Some(id)
5560 } else {
5561 context.overlay_owner
5562 };
5563 if let Some(options) = overlay_options {
5564 self.overlay_options.insert(id, options);
5565 self.overlay_parents.insert(id, context.overlay_owner);
5566 }
5567
5568 let host_options = if id == self.root {
5569 Some(pod.current_stack_host_options().unwrap_or_default())
5570 } else {
5571 pod.current_stack_host_options()
5572 };
5573 let is_stack_host = host_options.is_some();
5574 let resolved_host = if is_stack_host {
5575 id
5576 } else {
5577 context.stack_host
5578 };
5579 let host_policy = host_options
5580 .map(|options| options.order_policy)
5581 .unwrap_or(StackOrderPolicy::Stable);
5582 if is_stack_host {
5583 self.host_order_policy.insert(resolved_host, host_policy);
5584 } else {
5585 self.host_order_policy
5586 .entry(resolved_host)
5587 .or_insert(StackOrderPolicy::Stable);
5588 }
5589 let resolved_policy = *self
5590 .host_order_policy
5591 .get(&resolved_host)
5592 .unwrap_or(&StackOrderPolicy::Stable);
5593
5594 let surface_options = pod.current_stack_surface_options();
5595 let emits_layer = pod.current_layer_options().emits_layer();
5596 let is_direct_child_of_host = parent == Some(resolved_host);
5597 let is_stack_surface = id != self.root
5598 && emits_layer
5599 && (surface_options.is_some() || is_direct_child_of_host);
5600 let hit_test = !inert && surface_options.is_none_or(|options| options.hit_test);
5601 let resolved_surface = if is_stack_surface {
5602 id
5603 } else {
5604 context.stack_surface
5605 };
5606 let transient_owner_surface = surface_options
5607 .filter(|options| emits_layer && options.transient && context.stack_surface != id)
5608 .map(|_| context.stack_surface);
5609 if is_stack_surface {
5610 let surfaces = self.host_surface_order.entry(resolved_host).or_default();
5611 if !surfaces.contains(&id) {
5612 surfaces.push(id);
5613 }
5614 }
5615 if is_stack_surface && let Some(owner) = overlay_owner {
5616 self.overlay_surfaces.entry(owner).or_default().push(id);
5617 }
5618 let stack_surface_order = self
5619 .host_surface_order
5620 .get(&resolved_host)
5621 .and_then(|surfaces| {
5622 surfaces
5623 .iter()
5624 .position(|surface| *surface == resolved_surface)
5625 })
5626 .unwrap_or(0);
5627
5628 let children = {
5629 let mut children = self.child_buffers.pop().unwrap_or_default();
5630 children.clear();
5631 let mut visitor = CollectChildrenVisitor {
5632 graph: self,
5633 parent: id,
5634 focused_widget,
5635 paint_bounds_by_widget,
5636 context: GraphCollectContext {
5637 stack_host: resolved_host,
5638 stack_surface: resolved_surface,
5639 overlay_owner,
5640 inert,
5641 },
5642 children,
5643 inverse_cache,
5644 };
5645 pod.visit_children(&mut visitor);
5646 visitor.children
5647 };
5648
5649 let local_bounds = pod.bounds();
5650 let presentation_transform = pod.presentation_transform();
5651 let inverse_presentation_transform = if presentation_transform.is_identity() {
5652 Some(Transform::IDENTITY)
5653 } else {
5654 *inverse_cache
5655 .entry(transform_bits(presentation_transform))
5656 .or_insert_with(|| presentation_transform.inverse())
5657 };
5658 let layout_bounds = presentation_transform.transform_rect_bbox(local_bounds);
5659 let input_bounds = layout_bounds;
5660 let paint_bounds = paint_bounds_by_widget
5661 .get(&id)
5662 .copied()
5663 .unwrap_or(layout_bounds);
5664
5665 self.nodes.insert(
5666 id,
5667 WidgetNodeSnapshot {
5668 id,
5669 widget_name: pod.debug_name(),
5670 parent,
5671 children,
5672 measured_size: pod.measured_size(),
5673 geometry: WidgetGeometrySnapshot::new(layout_bounds, input_bounds, paint_bounds),
5674 local_bounds,
5675 presentation_transform,
5676 inverse_presentation_transform,
5677 bounds: layout_bounds,
5678 paint_boundary: pod.current_paint_boundary_mode(),
5679 stack_host: resolved_host,
5680 stack_surface: resolved_surface,
5681 stack_surface_order,
5682 transient_owner_surface,
5683 overlay_owner,
5684 is_overlay_owner,
5685 is_stack_host,
5686 is_stack_surface,
5687 hit_test,
5688 hit_test_self: pod.current_hit_test_self(),
5689 stack_order_policy: resolved_policy,
5690 accepts_focus: !inert && pod.accepts_focus(),
5691 focused: Some(id) == focused_widget,
5692 inert,
5693 },
5694 );
5695 }
5696
5697 fn hit_test_node(&self, widget_id: WidgetId, point: Point) -> Option<WidgetId> {
5698 let node = self.node(widget_id)?;
5699 if !node.hit_test || !node.geometry.input_bounds.contains(point) {
5700 return None;
5701 }
5702 let local_point = node.inverse_presentation_transform?.transform_point(point);
5703 if !node.local_bounds.contains(local_point) {
5704 return None;
5705 }
5706
5707 if node.is_stack_host {
5708 let mut tested_surfaces = HashSet::new();
5709 if let Some(ordered_surfaces) = self.host_surface_order.get(&node.id) {
5710 for surface_id in ordered_surfaces.iter().rev().copied() {
5711 if surface_id == widget_id {
5712 continue;
5713 }
5714 tested_surfaces.insert(surface_id);
5715 if let Some(hit) = self.hit_test_node(surface_id, point) {
5716 return Some(hit);
5717 }
5718 }
5719 }
5720
5721 for child_id in node.children.iter().rev() {
5722 if self.node(*child_id).is_some_and(|child| {
5723 child.is_stack_surface || tested_surfaces.contains(child_id)
5724 }) {
5725 continue;
5726 }
5727 if let Some(hit) = self.hit_test_node(*child_id, point) {
5728 return Some(hit);
5729 }
5730 }
5731
5732 return node.hit_test_self.then_some(widget_id);
5733 }
5734
5735 for child_id in node.children.iter().rev() {
5736 if let Some(hit) = self.hit_test_node(*child_id, point) {
5737 return Some(hit);
5738 }
5739 }
5740
5741 node.hit_test_self.then_some(widget_id)
5742 }
5743}
5744
5745struct CollectChildrenVisitor<'a> {
5746 graph: &'a mut WidgetGraph,
5747 parent: WidgetId,
5748 focused_widget: Option<WidgetId>,
5749 paint_bounds_by_widget: &'a FxHashMap<WidgetId, Rect>,
5750 context: GraphCollectContext,
5751 children: Vec<WidgetId>,
5752 inverse_cache: &'a mut FxHashMap<[u32; 6], Option<Transform>>,
5753}
5754
5755impl WidgetPodVisitor for CollectChildrenVisitor<'_> {
5756 fn visit(&mut self, child: &WidgetPod) {
5757 self.children.push(child.id());
5758 self.graph.collect(
5759 child,
5760 Some(self.parent),
5761 self.focused_widget,
5762 self.paint_bounds_by_widget,
5763 self.context,
5764 self.inverse_cache,
5765 );
5766 }
5767}
5768
5769fn transform_bits(transform: Transform) -> [u32; 6] {
5770 [
5771 transform.xx.to_bits(),
5772 transform.yx.to_bits(),
5773 transform.xy.to_bits(),
5774 transform.yy.to_bits(),
5775 transform.dx.to_bits(),
5776 transform.dy.to_bits(),
5777 ]
5778}
5779
5780struct EventRouteResult {
5781 path: Vec<WidgetId>,
5782 effects: EventEffects,
5783 focus_request: Option<FocusRequest>,
5784 handled: bool,
5785}
5786
5787#[derive(Default)]
5788struct HoverTransitionResult {
5789 effects: EventEffects,
5790 focus_request: Option<FocusRequest>,
5791 skip_primary_route: bool,
5792}
5793
5794#[derive(Default)]
5795struct EventEffects {
5796 invalidations: Vec<InvalidationRequest>,
5797 wake_requests: Vec<WakeRequest>,
5798 pointer_capture_requests: Vec<PointerCaptureRequest>,
5799 cursor_requests: Vec<CursorRequest>,
5800 drag_requests: Vec<DragRequest>,
5801 drop_acceptances: Vec<DropAcceptanceRequest>,
5802 posted_events: Vec<widget::PostedEventRequest>,
5803 posted_commands: Vec<widget::PostedCommandRequest>,
5804}
5805
5806impl EventEffects {
5807 fn extend(&mut self, dispatch: widget::EventDispatch) {
5808 self.invalidations.extend(dispatch.invalidations);
5809 self.wake_requests.extend(dispatch.wake_requests);
5810 self.pointer_capture_requests
5811 .extend(dispatch.pointer_capture_requests);
5812 self.cursor_requests.extend(dispatch.cursor_requests);
5813 self.drag_requests.extend(dispatch.drag_requests);
5814 self.drop_acceptances.extend(dispatch.drop_acceptances);
5815 self.posted_events.extend(dispatch.posted_events);
5816 self.posted_commands.extend(dispatch.posted_commands);
5817 }
5818
5819 fn merge(&mut self, effects: EventEffects) {
5820 self.invalidations.extend(effects.invalidations);
5821 self.wake_requests.extend(effects.wake_requests);
5822 self.pointer_capture_requests
5823 .extend(effects.pointer_capture_requests);
5824 self.cursor_requests.extend(effects.cursor_requests);
5825 self.drag_requests.extend(effects.drag_requests);
5826 self.drop_acceptances.extend(effects.drop_acceptances);
5827 self.posted_events.extend(effects.posted_events);
5828 self.posted_commands.extend(effects.posted_commands);
5829 }
5830}
5831
5832fn empty_dispatch() -> widget::EventDispatch {
5833 widget::EventDispatch {
5834 handled: false,
5835 invalidations: Vec::new(),
5836 focus_request: None,
5837 wake_requests: Vec::new(),
5838 pointer_capture_requests: Vec::new(),
5839 cursor_requests: Vec::new(),
5840 drag_requests: Vec::new(),
5841 drop_acceptances: Vec::new(),
5842 posted_events: Vec::new(),
5843 posted_commands: Vec::new(),
5844 }
5845}
5846
5847const MAX_PENDING_TRACE_SAMPLES: usize = 512;
5848const MAX_INSPECTOR_HISTORY_SAMPLES: usize = 256;
5849
5850fn push_trace<T>(samples: &mut Vec<T>, sample: T) {
5851 if samples.len() == MAX_PENDING_TRACE_SAMPLES {
5852 samples.remove(0);
5853 }
5854 samples.push(sample);
5855}
5856
5857fn extend_traces<T>(samples: &mut Vec<T>, additions: impl IntoIterator<Item = T>) {
5858 for sample in additions {
5859 push_trace(samples, sample);
5860 }
5861}
5862
5863fn push_inspector_history<T>(samples: &mut VecDeque<T>, sample: T) {
5864 if samples.len() == MAX_INSPECTOR_HISTORY_SAMPLES {
5865 samples.pop_front();
5866 }
5867 samples.push_back(sample);
5868}
5869
5870fn extend_inspector_history<T>(samples: &mut VecDeque<T>, additions: impl IntoIterator<Item = T>) {
5871 for sample in additions {
5872 push_inspector_history(samples, sample);
5873 }
5874}
5875
5876fn command_sample(
5877 command: &QueuedCommand,
5878 handlers: Vec<String>,
5879 handled: bool,
5880 delivered: bool,
5881) -> CommandDispatchSample {
5882 CommandDispatchSample {
5883 sequence: command.sequence,
5884 name: command.key.name.to_string(),
5885 payload_type: command.key.payload_type_name.to_string(),
5886 target: command.target,
5887 delivery: command.delivery,
5888 handlers,
5889 handled,
5890 delivered,
5891 }
5892}
5893
5894fn event_trace_source(event: &Event) -> String {
5895 let kind = match event {
5896 Event::Pointer(event) => format!("pointer:{:?}", event.kind),
5897 Event::RawMouseMotion(_) => "raw-mouse-motion".to_string(),
5898 Event::Drag(event) => format!("drag:{:?}", event.kind),
5899 Event::Keyboard(_) => "keyboard".to_string(),
5900 Event::Ime(_) => "ime".to_string(),
5901 Event::Semantics(_) => "semantics".to_string(),
5902 Event::Wake(event) => format!("wake:{event:?}"),
5903 Event::Window(event) => format!("window:{event:?}"),
5904 Event::Custom(event) => format!("custom:{}", event.kind),
5905 };
5906 format!("event:{kind}")
5907}
5908
5909fn inspector_event_kind(event: &Event) -> &'static str {
5910 match event {
5911 Event::Pointer(_) => "pointer",
5912 Event::RawMouseMotion(_) => "raw-mouse-motion",
5913 Event::Drag(_) => "drag",
5914 Event::Keyboard(_) => "keyboard",
5915 Event::Ime(_) => "ime",
5916 Event::Semantics(_) => "semantics",
5917 Event::Wake(_) => "wake",
5918 Event::Window(_) => "window",
5919 Event::Custom(_) => "custom",
5920 }
5921}
5922
5923fn drag_key_modifiers(key: &KeyboardEvent) -> Modifiers {
5926 let mut modifiers = key.modifiers;
5927 let pressed = key.state == KeyState::Pressed;
5928 match key.key.as_str() {
5929 "Shift" => modifiers.shift = pressed,
5930 "Control" => modifiers.control = pressed,
5931 "Alt" | "AltGraph" => modifiers.alt = pressed,
5932 "Meta" | "Super" => modifiers.meta = pressed,
5933 _ => {}
5934 }
5935 modifiers
5936}
5937
5938fn nearest_drop_acceptance(
5939 acceptances: &[DropAcceptanceRequest],
5940 path: &[WidgetId],
5941) -> Option<DropAcceptanceRequest> {
5942 acceptances
5943 .iter()
5944 .filter_map(|acceptance| {
5945 path.iter()
5946 .position(|widget_id| *widget_id == acceptance.target)
5947 .map(|index| (index, *acceptance))
5948 })
5949 .max_by_key(|(index, _)| *index)
5950 .map(|(_, acceptance)| acceptance)
5951}
5952
5953fn collect_dirty_regions<F>(
5954 viewport: Size,
5955 invalidations: &[InvalidationRequest],
5956 repainted: bool,
5957 default_region_for: F,
5958) -> Vec<DirtyRegion>
5959where
5960 F: FnMut(&InvalidationRequest) -> Rect,
5961{
5962 let viewport_rect = Rect::from_origin_size(Point::ZERO, viewport);
5963 let mut default_region_for = default_region_for;
5964
5965 if invalidations.is_empty() {
5966 return if repainted {
5967 vec![DirtyRegion::new(viewport_rect, InvalidationKind::Paint)]
5968 } else {
5969 Vec::new()
5970 };
5971 }
5972 let mut dirty_regions: Vec<_> = invalidations
5973 .iter()
5974 .map(|request| {
5975 DirtyRegion::new(
5976 request
5977 .region
5978 .unwrap_or_else(|| default_region_for(request)),
5979 request.kind,
5980 )
5981 })
5982 .collect();
5983
5984 if repainted
5985 && dirty_regions
5986 .iter()
5987 .all(|region| region.kind != InvalidationKind::Paint)
5988 {
5989 dirty_regions.push(DirtyRegion::new(viewport_rect, InvalidationKind::Paint));
5990 }
5991
5992 dirty_regions
5993}
5994
5995fn collect_scene_layers(scene: &Scene) -> HashMap<WidgetId, SceneLayerDescriptor> {
5996 let mut layers = HashMap::new();
5997 scene.visit_layers(&mut |layer| {
5998 layers.insert(layer.widget_id(), layer.descriptor.clone());
5999 });
6000 layers
6001}
6002
6003const TEXT_LAYOUT_PRUNE_SLACK: usize = 64;
6006
6007fn retain_text_layouts_for_scene(text_system: &TextSystem, scene: &Scene) {
6008 text_system.retain_persistent_layouts(&active_text_layout_handles(scene));
6009}
6010
6011fn active_text_layout_handles(scene: &Scene) -> HashSet<TextLayoutHandle> {
6012 let mut handles = HashSet::new();
6013 scene.visit_commands(&mut |command| match command {
6014 SceneCommand::DrawShapedText(text) => {
6015 handles.insert(text.layout_handle);
6016 }
6017 SceneCommand::DrawShapedTextWindow(text) => {
6018 handles.insert(text.layout_handle);
6019 }
6020 _ => {}
6021 });
6022 handles
6023}
6024
6025fn same_layer_translation(boundary_delta: Vector, delta: Vector) -> bool {
6029 const TOLERANCE: f32 = 1.0 / 64.0;
6030 (boundary_delta.x - delta.x).abs() <= TOLERANCE
6031 && (boundary_delta.y - delta.y).abs() <= TOLERANCE
6032}
6033
6034fn resolve_snapshot_paint_boundary_or_root(
6037 nodes: &FxHashMap<WidgetId, WidgetNodeSnapshot>,
6038 root: WidgetId,
6039 widget_id: WidgetId,
6040) -> WidgetId {
6041 let mut current = Some(widget_id);
6042 while let Some(candidate) = current {
6043 let Some(node) = nodes.get(&candidate) else {
6044 break;
6045 };
6046 if node.paint_boundary == PaintBoundaryMode::Explicit {
6047 return candidate;
6048 }
6049 current = node.parent;
6050 }
6051 root
6052}
6053
6054#[derive(Debug, Clone, Copy, PartialEq, Eq)]
6055enum HitTestCompositionPhase {
6056 Normal,
6057 Overlay,
6058 Effect,
6059}
6060
6061fn scene_hit_test_for_phase(
6062 scene: &Scene,
6063 point: Point,
6064 target_phase: HitTestCompositionPhase,
6065 inherited_phase: HitTestCompositionPhase,
6066) -> Option<WidgetId> {
6067 for command in scene.commands().iter().rev() {
6068 let SceneCommand::Layer(layer) = command else {
6069 continue;
6070 };
6071
6072 let layer_phase = next_hit_test_phase(inherited_phase, layer.descriptor.composition_mode);
6073 if !layer.descriptor.paint_bounds.contains(point) {
6074 continue;
6075 }
6076 if !layer.descriptor.hit_test {
6077 continue;
6078 }
6079
6080 if let Some(hit) = scene_hit_test_for_phase(&layer.scene, point, target_phase, layer_phase)
6081 {
6082 return Some(hit);
6083 }
6084
6085 if layer_phase == target_phase {
6086 return Some(layer.widget_id());
6087 }
6088 }
6089
6090 None
6091}
6092
6093fn next_hit_test_phase(
6094 inherited_phase: HitTestCompositionPhase,
6095 composition_mode: LayerCompositionMode,
6096) -> HitTestCompositionPhase {
6097 match (inherited_phase, composition_mode) {
6098 (HitTestCompositionPhase::Effect, _) | (_, LayerCompositionMode::Effect) => {
6099 HitTestCompositionPhase::Effect
6100 }
6101 (HitTestCompositionPhase::Overlay, _) | (_, LayerCompositionMode::Overlay) => {
6102 HitTestCompositionPhase::Overlay
6103 }
6104 _ => HitTestCompositionPhase::Normal,
6105 }
6106}
6107
6108fn root_repaint_covers_graph_changes(
6109 root: WidgetId,
6110 invalidations: &[InvalidationRequest],
6111) -> bool {
6112 let root_transform = invalidations.iter().any(|request| {
6113 request.kind == InvalidationKind::Transform
6114 && request.target == InvalidationTarget::Widget(root)
6115 });
6116 let root_content = invalidations.iter().any(|request| {
6117 matches!(
6118 request.kind,
6119 InvalidationKind::Measure
6120 | InvalidationKind::Clip
6121 | InvalidationKind::Visibility
6122 | InvalidationKind::Paint
6123 | InvalidationKind::Text
6124 | InvalidationKind::Resources
6125 ) && request.target == InvalidationTarget::Widget(root)
6126 });
6127 root_transform && root_content
6128}
6129
6130fn invalidation_to_layer_update_kind(kind: InvalidationKind) -> Option<SceneLayerUpdateKind> {
6131 match kind {
6132 InvalidationKind::Measure | InvalidationKind::Arrange | InvalidationKind::Transform => {
6133 Some(SceneLayerUpdateKind::Transform)
6134 }
6135 InvalidationKind::Ordering => Some(SceneLayerUpdateKind::Ordering),
6136 InvalidationKind::Clip => Some(SceneLayerUpdateKind::Clip),
6137 InvalidationKind::Effect => Some(SceneLayerUpdateKind::Effect),
6138 InvalidationKind::Visibility => Some(SceneLayerUpdateKind::Visibility),
6139 InvalidationKind::Paint | InvalidationKind::Text => Some(SceneLayerUpdateKind::Content),
6140 InvalidationKind::Resources => Some(SceneLayerUpdateKind::Resources),
6141 InvalidationKind::HitTest | InvalidationKind::Semantics => None,
6142 }
6143}
6144
6145fn merge_layer_update_kind(
6146 updates: &mut HashMap<WidgetId, SceneLayerUpdateKind>,
6147 widget_id: WidgetId,
6148 kind: SceneLayerUpdateKind,
6149) {
6150 updates
6151 .entry(widget_id)
6152 .and_modify(|current| {
6153 if layer_update_priority(kind) > layer_update_priority(*current) {
6154 *current = kind;
6155 }
6156 })
6157 .or_insert(kind);
6158}
6159
6160fn layer_update_priority(kind: SceneLayerUpdateKind) -> u8 {
6161 match kind {
6162 SceneLayerUpdateKind::Visibility => 0,
6163 SceneLayerUpdateKind::Ordering => 1,
6164 SceneLayerUpdateKind::Transform => 2,
6165 SceneLayerUpdateKind::Clip => 3,
6166 SceneLayerUpdateKind::Content => 4,
6167 SceneLayerUpdateKind::Effect => 5,
6168 SceneLayerUpdateKind::Resources => 6,
6169 }
6170}
6171
6172#[derive(Debug, Clone, PartialEq)]
6173pub struct RenderOutput {
6174 pub title: String,
6175 pub frame: SceneFrame,
6176 pub semantics: Vec<SemanticsNode>,
6177 pub ime_composition_rect: Option<Rect>,
6181 pub diagnostics: RenderDiagnostics,
6182}
6183
6184#[cfg(test)]
6185mod tests;