Skip to main content

sui_runtime/
lib.rs

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