Skip to main content

xrack_layout/
lib.rs

1//! Logical-pixel layout shared by software rendering and input hit testing.
2mod button;
3mod calendar;
4mod choice;
5mod clip;
6mod delay_button;
7mod drag;
8mod edit;
9mod file_drop;
10mod flow;
11mod focus_observers;
12mod focus_scope;
13mod geometry;
14mod grid;
15mod group_box;
16mod history;
17mod hover_observers;
18mod image;
19mod input;
20mod keyboard;
21mod label;
22mod linear;
23mod list_anchor;
24mod menu;
25mod modal;
26mod overscroll;
27mod page;
28mod page_indicator;
29mod password;
30mod path_view;
31mod pointer_events;
32mod popup;
33mod range;
34mod row_layout;
35mod scale_rotate;
36#[doc(hidden)]
37pub mod scale_rotate_gestures;
38mod scroll_bar;
39mod scroll_gesture;
40mod search;
41mod selection;
42mod shortcut;
43mod spin;
44mod split;
45mod stack_transition;
46mod styled_text;
47mod swipe_delegate;
48mod swipe_gesture;
49mod tab_move;
50mod table;
51mod table_drag_selection;
52mod text_area;
53mod tooltip;
54mod transform;
55mod tree;
56mod tumbler;
57mod view_cells;
58mod viewport;
59mod visual_text;
60mod window_chrome;
61pub use button::{ButtonContent, ButtonPlacement};
62pub use calendar::{CalendarDay, CalendarGeometry, CalendarWeek};
63pub use choice::{ChoiceKey, ChoiceMenu, ComboCompletion, ComboGeometry};
64use clip::ClipChain;
65pub use clip::{RoundedClip, corner_radii, normalize_radii};
66pub use delay_button::ButtonHoldEvent;
67pub use drag::{DragDispatch, DragUpdate};
68#[doc(hidden)]
69pub use edit::selection_drag_axis;
70pub use edit::{EditAction, TextEdit, TextEditContext, TextPosition};
71pub use file_drop::{FileDragInput, FileDropScope};
72pub use focus_observers::{FocusDelivery, FocusObservers};
73pub use geometry::{Point, Rect, Size};
74pub use group_box::group_header;
75pub use history::EditSource;
76pub use hover_observers::{HoverDelivery, HoverObservers};
77pub use image::{ImagePlacement, ImagePresentation, ImageRegion, fitted_rect, tile_extent};
78pub use input::{
79    ActivationKey, ControlInput, Interaction, NavigationKey, RangeInput, ScrollBarUpdate,
80    SliderKey, SplitResize, TableEditCommit, TableEditTarget, TablePasteDestination,
81    TableSelectionKey, Target, TextLinkTarget, WheelAdjustment, WheelRoute,
82};
83pub use keyboard::KeyRoute;
84pub use label::{
85    LabelLayout, LabelLine, LabelPlan, PlannedLabelLine, TextAlignment, uses_label_layout,
86};
87pub use menu::{MenuEntry, MenuKey, MenuPanel, MenuRow};
88pub use modal::{dialog_title_height, drawer_grip};
89pub use overscroll::OverscrollFrame;
90pub use page_indicator::{PageIndicatorGeometry, PageMarker};
91pub use password::PasswordMask;
92pub use pointer_events::{ButtonClick, PointerDelivery, PointerSequence, pointer_click_follows};
93pub use range::{ColorPlaneGeometry, DialGeometry, SliderGeometry, progress_fill_bounds};
94#[doc(hidden)]
95pub use row_layout::{RowLayoutCache, RowLayoutStats};
96pub use scale_rotate::{ScaleRotateTarget, TouchTransform, touch_centroid};
97pub use scroll_bar::ScrollBarGeometry;
98pub use scroll_gesture::{ScrollGestureEnd, ScrollGestureKind};
99pub use search::SearchGeometry;
100pub use selection::{TAB_LABEL_SIZE, tab_content_rect};
101pub use shortcut::{MenuShortcut, ShortcutKey, ShortcutModifiers, ShortcutOutcome};
102pub use spin::SpinGeometry;
103pub use split::{SplitGeometry, SplitHandle, SplitHandleRange};
104pub use stack_transition::{StackSlide, StackTransitions};
105use std::{collections::BTreeMap, rc::Rc, sync::Arc};
106pub use styled_text::{StyledFragment, StyledTextLayout};
107pub use swipe_delegate::SwipeDelegateGeometry;
108pub use swipe_gesture::SwipeDelivery;
109pub use table::TableGeometry;
110pub use text_area::{
111    TextAreaLayout, TextAreaMotion, text_editor_line_bounds, text_editor_viewport,
112};
113pub use tooltip::{TooltipPopup, layout_tooltip};
114pub use transform::Affine;
115use transform::TransformSpace;
116pub use tree::TreeRowGeometry;
117pub use tumbler::{TumblerGeometry, TumblerRow, TumblerScroll};
118pub use view_cells::ListSectionHeader;
119use view_cells::ViewCells;
120pub use viewport::{LayoutObservers, ScrollDelivery, ViewportObservers};
121pub use visual_text::{VisualGrapheme, VisualTextLine};
122pub use window_chrome::WindowResizeEdge;
123use xrack_runtime::{
124    Component, LayoutDirection, ListMetrics, Node, Orientation, RowKey, SelectionTarget,
125    group_index, is_font_family_choice, is_modal_overlay, is_window_overlay,
126    set_font_family_choices,
127};
128
129#[cfg(test)]
130mod tests;
131
132pub const DEFAULT_FONT_SIZE: f32 = 16.0;
133
134pub trait TextMeasurer {
135    fn measure(&mut self, text: &str, font_size: f32, max_width: f32) -> Size;
136
137    fn begin_window(&mut self, _scene: &Node) {}
138
139    /// Font families available for the current window, including embedded fonts.
140    fn font_families(&self) -> &[String] {
141        &[]
142    }
143
144    fn default_font_size(&self) -> Option<f32> {
145        None
146    }
147
148    fn font_size(&self, node: &Node) -> f32 {
149        node.font_size()
150            .or_else(|| self.default_font_size())
151            .unwrap_or(DEFAULT_FONT_SIZE)
152            .clamp(1.0, 512.0)
153    }
154
155    fn measure_node(&mut self, node: &Node, text: &str, max_width: f32) -> Size {
156        self.measure(text, self.font_size(node), max_width)
157    }
158
159    fn layout_styled_text(&mut self, node: &Node, available: Size) -> Option<StyledTextLayout> {
160        let document = node.styled_text("text")?;
161        let size = self.font_size(node);
162        Some(StyledTextLayout::new(
163            node,
164            document,
165            available,
166            size,
167            |text, _| self.measure_node(node, text, f32::MAX).width,
168        ))
169    }
170
171    fn measure_label(&mut self, node: &Node, max_width: f32) -> Size {
172        if let Some(plan) = self.layout_styled_text(node, Size::new(max_width, f32::INFINITY)) {
173            return plan.size;
174        }
175        LabelLayout::with_font_size(
176            node,
177            Size::new(max_width, f32::INFINITY),
178            self.font_size(node),
179            |value| self.measure_node(node, value, f32::MAX).width,
180        )
181        .size
182    }
183}
184
185#[derive(Clone, Debug, PartialEq)]
186struct TransformPlacement {
187    local: Affine,
188    parent_clip: Rect,
189    parent_space: Option<Arc<TransformSpace>>,
190}
191
192#[derive(Clone, Debug, PartialEq)]
193pub struct LayoutNode {
194    pub bounds: Rect,
195    /// Rectangular part of the ancestor clip.
196    pub clip: Rect,
197    pub visible: bool,
198    pub enabled: bool,
199    pub layout_direction: LayoutDirection,
200    direction_override: Option<LayoutDirection>,
201    pub(crate) content_bounds: Option<Box<Rect>>,
202    pub scroll: Option<ScrollLayout>,
203    list_section_headers: Option<Box<[ListSectionHeader]>>,
204    horizontal_scroll: Option<ScrollLayout>,
205    horizontal_scroll_reversed: bool,
206    viewport_handle: Option<xrack_runtime::ViewportHandle>,
207    nested_list: Option<xrack_runtime::ListRowRenderer>,
208    missing_list_rows: bool,
209    missing_descendant_list_rows: bool,
210    attached_scroll_bar: Option<Box<scroll_bar::AttachedScrollBar>>,
211    mouse_drag_pan: bool,
212    middle_mouse_pan: bool,
213    pan_axes: [bool; 2],
214    elastic: Option<overscroll::ElasticOptions>,
215    pub table: Option<Box<TableGeometry>>,
216    pub split: Option<Box<SplitGeometry>>,
217    /// Header hit box of a tab, independent of the page visibility.
218    pub tab_header: Option<Rect>,
219    /// Close button bounds within a tab header or standalone tab button.
220    pub tab_close: Option<Rect>,
221    tab_strip: Option<Rect>,
222    pub tumbler: Option<Box<TumblerGeometry>>,
223    /// Logical thumb position while a switch gesture is active.
224    pub switch_position: Option<f32>,
225    pub swipe_delegate: Option<Box<SwipeDelegateGeometry>>,
226    #[doc(hidden)]
227    pub swipe_preview: Option<Box<LayoutNode>>,
228    pub styled_text: Option<Box<StyledTextLayout>>,
229    font_size: f32,
230    overlays: Option<Box<modal::OverlayIndex>>,
231    paint_order: Option<xrack_runtime::ScenePlanSlice<usize>>,
232    overflow: bool,
233    child_shape: Option<RoundedClip>,
234    ancestor_shapes: Option<Arc<ClipChain>>,
235    space: Option<Arc<TransformSpace>>,
236    transform: Option<Box<TransformPlacement>>,
237    table_pane: Option<Box<(Rect, Affine)>>,
238    table_column_window: xrack_runtime::TableColumnWindow,
239    pub children: Vec<LayoutNode>,
240}
241
242#[derive(Clone, Copy, Debug, PartialEq)]
243pub struct ScrollLayout {
244    pub offset: f32,
245    pub max_offset: f32,
246}
247
248impl ScrollLayout {
249    pub(crate) fn new(requested: f32, max_offset: f32) -> Self {
250        let max_offset = max_offset.max(0.0);
251        Self {
252            offset: requested.clamp(0.0, max_offset),
253            max_offset,
254        }
255    }
256
257    pub(crate) fn revealing(self, top: f32, height: f32, viewport: f32) -> Self {
258        let offset = if top < self.offset {
259            top
260        } else {
261            self.offset.max(top + height - viewport)
262        };
263        Self::new(offset, self.max_offset)
264    }
265}
266
267/// Window-level registrations visible in a prepared scene.
268#[doc(hidden)]
269#[derive(Default)]
270pub struct WindowEffects<'a> {
271    pub button_animations: Vec<&'a xrack_runtime::ButtonPressHandle>,
272    pub timers: Vec<&'a xrack_runtime::TimerRegistration>,
273    pub dialogs: Vec<&'a xrack_runtime::NativeDialogRegistration>,
274    pub media: Vec<&'a xrack_runtime::MediaRegistration>,
275    pub playback: Vec<(&'a Rc<xrack_runtime::ImagePlaybackRegistration>, bool)>,
276}
277
278impl<'a> WindowEffects<'a> {
279    pub fn collect(node: &'a Node, layout: &LayoutNode) -> Self {
280        let mut effects = Self::default();
281        effects.extend(node, layout);
282        effects
283    }
284
285    fn extend(&mut self, node: &'a Node, layout: &LayoutNode) {
286        if node.expander_collapsed() {
287            return;
288        }
289        if let Some(handle) = node
290            .button_press_handle
291            .as_ref()
292            .filter(|handle| handle.supports_animation())
293        {
294            self.button_animations.push(handle);
295        }
296        self.timers.extend(layout.timer_registrations(node));
297        if layout.visible && layout.enabled {
298            self.dialogs.extend(&node.native_dialogs);
299        }
300        self.playback.extend(layout.image_playback(node));
301        if layout.visible {
302            self.media.extend(node.media.as_ref());
303        }
304        self.media.extend(&node.sound_effects);
305        for (child, item) in node.children.iter().zip(&layout.children) {
306            self.extend(child, item);
307        }
308    }
309}
310
311impl LayoutNode {
312    pub fn list_section_headers(&self) -> &[ListSectionHeader] {
313        self.list_section_headers.as_deref().unwrap_or_default()
314    }
315
316    /// The nearest explicit direction, including an inherited declaration.
317    pub fn layout_direction_override(&self) -> Option<LayoutDirection> {
318        self.direction_override
319    }
320
321    #[doc(hidden)]
322    pub fn has_missing_list_rows(&self) -> bool {
323        self.missing_list_rows || self.missing_descendant_list_rows
324    }
325
326    #[doc(hidden)]
327    pub fn timer_registrations<'a>(
328        &self,
329        node: &'a Node,
330    ) -> &'a [xrack_runtime::TimerRegistration] {
331        if self.visible { &node.timers } else { &[] }
332    }
333
334    pub fn image_playback<'a>(
335        &self,
336        node: &'a Node,
337    ) -> Option<(&'a Rc<xrack_runtime::ImagePlaybackRegistration>, bool)> {
338        let registration = node.image_playback.as_ref()?;
339        let clip = self.clip_rect(self.bounds);
340        Some((
341            registration,
342            self.visible && clip.width > 0.0 && clip.height > 0.0,
343        ))
344    }
345
346    pub fn allows_overflow(&self) -> bool {
347        self.overflow
348    }
349
350    pub fn child_clip_shape(&self) -> Option<RoundedClip> {
351        self.child_shape
352    }
353
354    pub fn local_transform(&self) -> Affine {
355        self.transform
356            .as_deref()
357            .map_or(Affine::IDENTITY, |transform| transform.local)
358    }
359
360    /// An exact table pane clip, expressed in the parent space before this item's transform.
361    pub fn table_pane_clip(&self) -> Option<(Rect, Affine)> {
362        self.table_pane.as_deref().copied()
363    }
364
365    pub fn world_transform(&self) -> Affine {
366        self.space
367            .as_deref()
368            .map_or(Affine::IDENTITY, |space| space.world)
369    }
370
371    fn inverse_transform(&self) -> Option<Affine> {
372        self.space
373            .as_deref()
374            .map_or(Some(Affine::IDENTITY), |space| space.inverse)
375    }
376
377    /// Undo the visual transform, returning pre-transform layout coordinates.
378    pub fn map_from_window(&self, point: Point) -> Option<Point> {
379        Some(self.inverse_transform()?.map_point(point))
380    }
381
382    pub fn map_delta_from_window(&self, delta: Point) -> Option<Point> {
383        Some(self.inverse_transform()?.map_vector(delta))
384    }
385
386    pub fn map_to_window(&self, point: Point) -> Point {
387        self.world_transform().map_point(point)
388    }
389
390    pub fn window_bounds(&self, rect: Rect) -> Rect {
391        self.world_transform().map_rect(rect)
392    }
393
394    /// Rectangular projection of the clipping region in layout coordinates.
395    pub fn clip_rect(&self, rect: Rect) -> Rect {
396        let rect = self.clip.intersect(rect);
397        let Some(inverse) = self.inverse_transform() else {
398            return Rect::default();
399        };
400        self.ancestor_shapes.as_deref().map_or(rect, |chain| {
401            chain.clip_rect(rect, self.world_transform(), inverse)
402        })
403    }
404
405    pub fn visible_window_bounds(&self, rect: Rect) -> Rect {
406        let rect = self.window_bounds(self.clip_rect(rect));
407        // The local projection can overestimate after a rotation; bound it
408        // once more in window space for anchors and native accessibility.
409        self.ancestor_shapes.as_deref().map_or(rect, |chain| {
410            chain.clip_rect(rect, Affine::IDENTITY, Affine::IDENTITY)
411        })
412    }
413
414    pub fn contains_clip_point(&self, point: Point) -> bool {
415        self.map_from_window(point)
416            .is_some_and(|local| self.clip.contains(local))
417            && self
418                .ancestor_shapes
419                .as_deref()
420                .is_none_or(|chain| chain.contains(point))
421    }
422
423    pub(crate) fn contains_subtree_point(&self, point: Point) -> bool {
424        self.visible
425            && self.contains_clip_point(point)
426            && (self.overflow
427                || self
428                    .map_from_window(point)
429                    .is_some_and(|local| self.bounds.contains(local)))
430    }
431
432    /// Back to front. Scene indices stay in declaration order for routing.
433    pub fn child_paint_order(&self) -> impl DoubleEndedIterator<Item = usize> + '_ {
434        (0..self.children.len()).map(|index| {
435            let dense = self
436                .paint_order
437                .as_deref()
438                .map_or(index, |order| order[index]);
439            self.table_column_window.logical_index(dense)
440        })
441    }
442
443    pub fn children_in_paint_order<'a>(
444        &'a self,
445        node: &'a Node,
446    ) -> impl DoubleEndedIterator<Item = (usize, &'a Node, &'a LayoutNode)> + 'a {
447        self.child_paint_order()
448            .filter_map(move |index| Some((index, node.child_at(index)?, self.child_at(index)?)))
449    }
450
451    pub(crate) fn children_in_scene_order<'a, 'b>(
452        &'b self,
453        node: &'a Node,
454    ) -> impl Iterator<Item = (usize, &'a Node, &'b LayoutNode)> {
455        node.materialized_children()
456            .zip(&self.children)
457            .map(|((index, child), layout)| (index, child, layout))
458    }
459
460    pub fn text_link_regions(&self) -> impl Iterator<Item = (usize, Rect)> + '_ {
461        self.styled_text
462            .iter()
463            .flat_map(|plan| &plan.fragments)
464            .filter_map(|fragment| {
465                let link = fragment.link()?;
466                let rect = fragment.bounds;
467                let visible = self.clip_rect(
468                    Rect::new(
469                        self.bounds.x + rect.x,
470                        self.bounds.y + rect.y,
471                        rect.width,
472                        rect.height,
473                    )
474                    .intersect(self.bounds),
475                );
476                (self.visible && visible.width > 0.0 && visible.height > 0.0)
477                    .then_some((link, visible))
478            })
479    }
480
481    pub fn group_header(&self, node: &Node) -> Rect {
482        group_box::header_with_font_size(node, self.bounds, self.font_size)
483    }
484
485    pub(crate) fn tab_viewport(&self) -> Rect {
486        self.tab_strip.unwrap_or(self.bounds)
487    }
488
489    pub(crate) fn tab_item_rect(&self, index: usize) -> Option<Rect> {
490        let child = self.child_at(index)?;
491        if self.tab_strip.is_some() {
492            child.tab_header
493        } else {
494            child.visible.then_some(child.bounds)
495        }
496    }
497
498    pub fn scroll_on(&self, orientation: Orientation) -> Option<ScrollLayout> {
499        match orientation {
500            Orientation::Horizontal => self
501                .table
502                .as_ref()
503                .map(|table| table.horizontal)
504                .or(self.horizontal_scroll),
505            Orientation::Vertical => self.scroll,
506        }
507    }
508
509    fn accepts_pan(&self, axis: Orientation, device: scroll_gesture::PanDevice) -> bool {
510        use scroll_gesture::PanDevice;
511        self.pan_axes[usize::from(axis == Orientation::Vertical)]
512            && match device {
513                PanDevice::Touch => true,
514                PanDevice::LeftMouse => self.mouse_drag_pan,
515                PanDevice::MiddleMouse => self.middle_mouse_pan,
516            }
517    }
518
519    /// Paths of visible modal overlays, in declaration order.
520    pub fn dialog_paths(&self) -> &[Vec<usize>] {
521        self.overlays
522            .as_ref()
523            .map_or(&[], |overlays| overlays.modal.as_slice())
524    }
525
526    /// Paths of all open overlays, in declaration order.
527    pub fn overlay_paths(&self) -> &[Vec<usize>] {
528        self.overlays
529            .as_ref()
530            .map_or(&[], |overlays| overlays.open.as_slice())
531    }
532
533    pub(crate) fn drawer_paths(&self) -> &[Vec<usize>] {
534        self.overlays
535            .as_ref()
536            .map_or(&[], |overlays| overlays.drawers.as_slice())
537    }
538
539    /// Look up a laid-out child by its logical scene index.
540    pub fn child_at(&self, index: usize) -> Option<&Self> {
541        self.children
542            .get(self.table_column_window.dense_index(index)?)
543    }
544
545    pub(crate) fn child_at_mut(&mut self, index: usize) -> Option<&mut Self> {
546        let dense = self.table_column_window.dense_index(index)?;
547        self.children.get_mut(dense)
548    }
549
550    pub fn at_path(&self, path: &[usize]) -> Option<&Self> {
551        let mut item = self;
552        for &index in path {
553            item = item.child_at(index)?;
554        }
555        Some(item)
556    }
557}
558
559fn sibling_paint_order(node: &Node, count: usize) -> Option<xrack_runtime::ScenePlanSlice<usize>> {
560    use xrack_runtime::ScenePlanSlice;
561
562    if node.has_natural_paint_order() {
563        return None;
564    }
565    if let Some(order) = node.paint_order_plan().filter(|order| order.len() == count) {
566        return Some(order.clone());
567    }
568    let children = &node.children[..count];
569    // Already ordered (including the default of all zeroes) needs no storage.
570    if !children.windows(2).any(|pair| pair[0].z() > pair[1].z()) {
571        return None;
572    }
573    let mut order: Vec<_> = (0..children.len()).collect();
574    order.sort_by(|&left, &right| children[left].z().total_cmp(&children[right].z()));
575    Some(ScenePlanSlice::Owned(order))
576}
577
578pub fn font_size(node: &Node) -> f32 {
579    node.font_size()
580        .unwrap_or(DEFAULT_FONT_SIZE)
581        .clamp(1.0, 512.0)
582}
583
584fn dimension(node: &Node, name: &str) -> Option<f32> {
585    node.length(name).map(|n| n.max(0.0))
586}
587
588fn default_toggle_indicator_size(node: &Node) -> Size {
589    match node.kind {
590        "Switch" => Size::new(36.0, 18.0),
591        "RadioButton" => Size::new(16.0, 16.0),
592        _ => Size::new(18.0, 18.0),
593    }
594}
595
596fn toggle_indicator_size(node: &Node) -> Option<Size> {
597    let indicator = node.control_part("ToggleIndicator")?;
598    let default = default_toggle_indicator_size(node);
599    Some(Size::new(
600        dimension(indicator, "width").unwrap_or(default.width),
601        dimension(indicator, "height").unwrap_or(default.height),
602    ))
603}
604
605/// Bounds shared by the built-in indicator, its replacement and the label.
606#[doc(hidden)]
607pub struct ToggleGeometry {
608    pub indicator: Rect,
609    pub label: Rect,
610    direction: LayoutDirection,
611    thumb_size: Size,
612}
613
614impl ToggleGeometry {
615    pub fn new(node: &Node, bounds: Rect, direction: LayoutDirection) -> Self {
616        let replacement = toggle_indicator_size(node);
617        let size = replacement.unwrap_or_else(|| {
618            let preferred = default_toggle_indicator_size(node);
619            let scale = (bounds.height / preferred.height).clamp(0.0, 1.0);
620            Size::new(preferred.width * scale, preferred.height * scale)
621        });
622        let delegate = node.is_item_delegate();
623        let inset = (if delegate { 12.0_f32 } else { 6.0 }).min(bounds.width);
624        let width = size.width.min((bounds.width - inset).max(0.0));
625        let height = size.height.min(bounds.height);
626        let x = if delegate {
627            bounds.x + bounds.width - inset - width
628        } else {
629            bounds.x + inset
630        };
631        let indicator = Rect::new(x, bounds.y + (bounds.height - height) * 0.5, width, height);
632        let (left, right) = if delegate {
633            (bounds.x + 12.0, x - 10.0)
634        } else if node.kind == "RadioButton" && replacement.is_none() {
635            (bounds.x + 28.0, bounds.x + bounds.width)
636        } else {
637            (x + width + 7.0, bounds.x + bounds.width)
638        };
639        let label = Rect::new(left, bounds.y, (right - left).max(0.0), bounds.height);
640        let thumb = node.control_part("SwitchThumb");
641        let diameter = (width.min(height) - 4.0).max(0.0);
642        let dimension = |name, available| {
643            thumb
644                .and_then(|thumb| thumb.relative_length(name, available))
645                .unwrap_or(diameter)
646                .clamp(0.0, available)
647        };
648        Self {
649            indicator: place_in_direction(indicator, bounds, direction),
650            label: place_in_direction(label, bounds, direction),
651            direction,
652            thumb_size: Size::new(dimension("width", width), dimension("height", height)),
653        }
654    }
655
656    pub fn switch_travel(&self) -> f32 {
657        (self.indicator.width - self.indicator.height.max(self.thumb_size.width)).max(0.0)
658    }
659
660    pub fn switch_thumb(&self, checked: bool, preview: Option<f32>) -> Rect {
661        let logical = preview.unwrap_or(if checked { 1.0 } else { 0.0 });
662        let visual = if self.direction == LayoutDirection::RightToLeft {
663            1.0 - logical
664        } else {
665            logical
666        };
667        let travel = self.switch_travel();
668        let bounds = self.indicator;
669        Rect::new(
670            bounds.x + (bounds.width - travel - self.thumb_size.width) * 0.5 + travel * visual,
671            bounds.y + (bounds.height - self.thumb_size.height) * 0.5,
672            self.thumb_size.width,
673            self.thumb_size.height,
674        )
675    }
676}
677
678/// Bounds of a supplied replacement indicator.
679#[doc(hidden)]
680pub fn toggle_indicator_rect(node: &Node, bounds: Rect) -> Option<Rect> {
681    node.control_part("ToggleIndicator")?;
682    Some(ToggleGeometry::new(node, bounds, node.layout_direction().unwrap_or_default()).indicator)
683}
684
685fn place_in_direction(mut rect: Rect, content: Rect, direction: LayoutDirection) -> Rect {
686    if direction == LayoutDirection::RightToLeft {
687        rect.x = content.x + content.width - (rect.x - content.x) - rect.width;
688    }
689    rect
690}
691
692fn participates_in_flow(node: &Node) -> bool {
693    !is_window_overlay(node.kind)
694        && !matches!(node.kind, "Menu" | "Tooltip" | "Shortcut")
695        && node.is_visible()
696}
697
698pub fn is_layout(kind: &str) -> bool {
699    matches!(
700        kind,
701        "GridLayout"
702            | "FlowLayout"
703            | "FlexboxLayout"
704            | "ToolBar"
705            | "Row"
706            | "RadioGroup"
707            | "SplitView"
708    ) || linear::Axis::for_layout(kind).is_some()
709}
710
711/// Child indices in visual reading order. Paths keep their original scene indices.
712pub fn child_reading_order(node: &Node) -> impl Iterator<Item = usize> {
713    let slots @ [menu, header, footer] = page::slots(node);
714    let count = node.table_column_window.logical_len(node.children.len());
715    let (ordered, len) =
716        if node.kind == "TableRow" && node.table_column_order.as_slice(count).is_some() {
717            let mut ordered: Vec<_> = node
718                .materialized_children()
719                .map(|(column, _)| column)
720                .collect();
721            ordered.sort_by_key(|&column| node.table_column_order.visual_index(count, column));
722            (ordered, 0)
723        } else if node.kind == "SplitView" {
724            let count = node.split_pane_count();
725            let ordered = (0..count)
726                .flat_map(|slot| [slot, count + slot])
727                .filter(|&slot| slot < node.children.len())
728                .collect();
729            (ordered, 0)
730        } else if matches!(node.kind, "DialogButtonBox" | "FlexboxLayout") {
731            let mut ordered = (0..node.children.len()).collect::<Vec<_>>();
732            ordered.sort_by_key(|&index| linear::item_order(node, &node.children[index]));
733            (ordered, 0)
734        } else {
735            (Vec::new(), node.children.len())
736        };
737    ordered
738        .into_iter()
739        .chain(menu)
740        .chain(header)
741        .chain(
742            (0..len)
743                .map(move |index| node.table_column_window.logical_index(index))
744                .filter(move |&index| !slots.contains(&Some(index))),
745        )
746        .chain(footer)
747}
748
749/// Root dimensions come from the actual viewport; DSL dimensions size the initial window.
750pub fn layout(scene: &Node, viewport: Size, text: &mut impl TextMeasurer) -> LayoutNode {
751    layout_with_scroll(scene, viewport, text, &BTreeMap::new())
752}
753
754pub fn layout_with_scroll(
755    scene: &Node,
756    viewport: Size,
757    text: &mut impl TextMeasurer,
758    offsets: &BTreeMap<Vec<usize>, f32>,
759) -> LayoutNode {
760    let mut layout = layout_with_offsets(scene, viewport, text, offsets, None);
761    scroll_bar::attach(scene, &mut layout, text);
762    layout
763}
764
765pub fn layout_with_input(
766    scene: &Node,
767    viewport: Size,
768    text: &mut impl TextMeasurer,
769    input: &Interaction,
770) -> LayoutNode {
771    let mut layout =
772        layout_with_offsets(scene, viewport, text, input.scroll_offsets(), Some(input));
773    scroll_bar::attach(scene, &mut layout, text);
774    layout
775}
776
777fn layout_with_offsets(
778    scene: &Node,
779    viewport: Size,
780    text: &mut impl TextMeasurer,
781    offsets: &BTreeMap<Vec<usize>, f32>,
782    input: Option<&Interaction>,
783) -> LayoutNode {
784    text.begin_window(scene);
785    layout_current_window(scene, viewport, text, offsets, input)
786}
787
788fn layout_current_window(
789    scene: &Node,
790    viewport: Size,
791    text: &mut impl TextMeasurer,
792    offsets: &BTreeMap<Vec<usize>, f32>,
793    input: Option<&Interaction>,
794) -> LayoutNode {
795    let bounds = Rect::new(0.0, 0.0, viewport.width.max(0.0), viewport.height.max(0.0));
796    let mut layout = LayoutContext {
797        text,
798        layout_direction: None,
799        offsets,
800        input,
801        path: Vec::new(),
802        row_key: None,
803        anchor: None,
804        resolved_list_scroll: None,
805        row_layouts: None,
806        ancestor_shapes: None,
807        space: None,
808        viewport: bounds,
809    }
810    .place(scene, bounds, bounds, true, true, None);
811    modal::index_overlays(scene, &mut layout);
812    layout
813}
814
815/// Place replacement artwork in the already resolved popup row.
816#[doc(hidden)]
817pub fn layout_choice_option(
818    node: &Node,
819    bounds: Rect,
820    direction: LayoutDirection,
821    enabled: bool,
822    text: &mut impl TextMeasurer,
823) -> LayoutNode {
824    LayoutContext {
825        text,
826        layout_direction: Some(direction),
827        offsets: &BTreeMap::new(),
828        input: None,
829        path: Vec::new(),
830        row_key: None,
831        anchor: None,
832        resolved_list_scroll: None,
833        row_layouts: None,
834        ancestor_shapes: None,
835        space: None,
836        viewport: bounds,
837    }
838    .place(node, bounds, bounds, true, enabled, None)
839}
840
841/// Resolve virtual rows after laying out the viewport containers. Row contents
842/// have no effect on the indexed row heights or scroll extent.
843pub fn prepare_scene(
844    component: &impl Component,
845    scene: Rc<Node>,
846    viewport: Size,
847    text: &mut impl TextMeasurer,
848    offsets: &BTreeMap<Vec<usize>, f32>,
849) -> (Rc<Node>, LayoutNode) {
850    prepare_scene_with_offsets(component, scene, viewport, text, offsets, None, None)
851}
852
853pub fn prepare_scene_with_input(
854    component: &impl Component,
855    scene: Rc<Node>,
856    viewport: Size,
857    text: &mut impl TextMeasurer,
858    input: &Interaction,
859) -> (Rc<Node>, LayoutNode) {
860    prepare_scene_with_offsets(
861        component,
862        scene,
863        viewport,
864        text,
865        input.scroll_offsets(),
866        Some(input),
867        None,
868    )
869}
870
871#[doc(hidden)]
872pub fn prepare_scene_with_row_cache(
873    component: &impl Component,
874    scene: Rc<Node>,
875    viewport: Size,
876    text: &mut impl TextMeasurer,
877    input: &Interaction,
878    cache: &mut RowLayoutCache,
879) -> (Rc<Node>, LayoutNode) {
880    cache.begin_frame(&scene);
881    let result = prepare_scene_with_offsets(
882        component,
883        scene,
884        viewport,
885        text,
886        input.scroll_offsets(),
887        Some(input),
888        Some(cache),
889    );
890    cache.finish_frame();
891    result
892}
893
894fn prepare_scene_with_offsets(
895    component: &impl Component,
896    mut scene: Rc<Node>,
897    viewport: Size,
898    text: &mut impl TextMeasurer,
899    offsets: &BTreeMap<Vec<usize>, f32>,
900    input: Option<&Interaction>,
901    row_layouts: Option<&mut RowLayoutCache>,
902) -> (Rc<Node>, LayoutNode) {
903    fn has_lists(node: &Node) -> bool {
904        node.list.is_some()
905            || node.children.iter().any(has_lists)
906            || node
907                .swipe_preview
908                .as_ref()
909                .and_then(|preview| preview.page.as_ref())
910                .is_some_and(|(_, page)| has_lists(page))
911    }
912
913    text.begin_window(&scene);
914    let families = text.font_families();
915    if !families.is_empty()
916        && let Some(populated) = populate_font_choices(&scene, families)
917    {
918        scene = Rc::new(populated);
919    }
920    let mut layout = layout_current_window(&scene, viewport, text, offsets, input);
921    if has_lists(&scene) {
922        let viewport = Rect::new(0.0, 0.0, viewport.width.max(0.0), viewport.height.max(0.0));
923        LayoutContext {
924            text,
925            layout_direction: None,
926            offsets,
927            input,
928            path: Vec::new(),
929            row_key: None,
930            anchor: None,
931            resolved_list_scroll: None,
932            row_layouts,
933            ancestor_shapes: None,
934            space: None,
935            viewport,
936        }
937        .populate_lists(component, Rc::make_mut(&mut scene), &mut layout);
938        modal::index_overlays(&scene, &mut layout);
939    }
940    scroll_bar::attach(&scene, &mut layout, text);
941    (scene, layout)
942}
943
944fn populate_font_choices(node: &Node, families: &[String]) -> Option<Node> {
945    if is_font_family_choice(node) {
946        let mut populated = node.clone();
947        set_font_family_choices(&mut populated, families);
948        return Some(populated);
949    }
950    let mut populated = None;
951    for (index, child) in node.children.iter().enumerate() {
952        if let Some(child) = populate_font_choices(child, families) {
953            populated.get_or_insert_with(|| node.clone()).children[index] = child;
954        }
955    }
956    populated
957}
958
959struct ScrollContent {
960    extent: Size,
961    children: Vec<Option<(f32, f32, f32, linear::AxisInfo)>>,
962}
963
964struct LayoutContext<'a, T> {
965    text: &'a mut T,
966    layout_direction: Option<LayoutDirection>,
967    offsets: &'a BTreeMap<Vec<usize>, f32>,
968    input: Option<&'a Interaction>,
969    path: Vec<usize>,
970    row_key: Option<RowKey>,
971    anchor: Option<Rect>,
972    resolved_list_scroll: Option<ScrollLayout>,
973    row_layouts: Option<&'a mut RowLayoutCache>,
974    ancestor_shapes: Option<Arc<ClipChain>>,
975    space: Option<Arc<TransformSpace>>,
976    viewport: Rect,
977}
978
979impl<T: TextMeasurer> LayoutContext<'_, T> {
980    fn requested_scroll(&self, node: &Node, orientation: Orientation) -> f32 {
981        self.scroll_request(node, orientation).unwrap_or_default()
982    }
983
984    fn scroll_request(&self, node: &Node, orientation: Orientation) -> Option<f32> {
985        if let Some(offset) = node
986            .viewport_handle
987            .as_ref()
988            .and_then(|handle| handle.bound_offset(orientation))
989        {
990            return Some(offset);
991        }
992        if orientation == Orientation::Vertical && self.tree_root_changed(node) {
993            return Some(0.0);
994        }
995        if self.row_key.is_some()
996            && let Some(renderer) = &node.list_row_renderer
997        {
998            return renderer.offset(orientation);
999        }
1000        let offsets = match orientation {
1001            Orientation::Horizontal => self.input.map(Interaction::horizontal_scroll_offsets),
1002            Orientation::Vertical => Some(self.offsets),
1003        };
1004        offsets.and_then(|offsets| offsets.get(&self.path)).copied()
1005    }
1006
1007    fn tree_root_changed(&self, node: &Node) -> bool {
1008        if self.row_key.is_some()
1009            && let Some(renderer) = &node.list_row_renderer
1010        {
1011            node.tree
1012                .as_ref()
1013                .is_some_and(|tree| renderer.tree_root_changed(tree.root_identity()))
1014        } else {
1015            self.input
1016                .is_some_and(|input| input.tree_root_changed(&self.path, node))
1017        }
1018    }
1019
1020    fn populate_lists(
1021        &mut self,
1022        component: &impl Component,
1023        node: &mut Node,
1024        layout: &mut LayoutNode,
1025    ) {
1026        if node.list.is_none() && node.children.is_empty() {
1027            return;
1028        }
1029        let previous_row = self.row_key;
1030        let previous_direction = self.layout_direction;
1031        self.row_key = node.routing_row_key().or(previous_row);
1032        self.layout_direction = layout.direction_override;
1033        if let Some(mut list) = node.list
1034            && !(list.row_count == 0
1035                && node
1036                    .children
1037                    .first()
1038                    .is_some_and(|child| child.kind == "EmptyState"))
1039        {
1040            let viewport = layout
1041                .table
1042                .as_ref()
1043                .map_or(layout.bounds, |table| table.body);
1044            let clipped = layout.clip_rect(
1045                layout
1046                    .table
1047                    .as_ref()
1048                    .map_or(viewport, |table| table.rows_area()),
1049            );
1050            let clipped = view_cells::list_body_clip(clipped, layout.list_section_headers());
1051            let range = if let Some(scroll) = layout.scroll
1052                && clipped.width > 0.0
1053                && clipped.height > 0.0
1054            {
1055                let top = f64::from(scroll.offset) + f64::from(clipped.y - viewport.y);
1056                let bottom = top + f64::from(clipped.height);
1057                ViewCells::new(node, viewport.width).visible(top, bottom, list.row_count)
1058            } else {
1059                0..0
1060            };
1061            list.first_row = range.start;
1062            let selected = ListMetrics::selection(node);
1063            let selection = node.table_selection.as_ref();
1064            let tree = node.tree.as_ref();
1065            let tree_selection = node.tree_selection.as_ref();
1066            let row_headers = layout
1067                .table
1068                .as_ref()
1069                .is_some_and(|table| table.row_header.width > 0.0);
1070            let indentation = node.length("indentation").unwrap_or(16.0).clamp(0.0, 64.0);
1071            let renderer = node.list_row_renderer.as_ref();
1072            let scope = renderer
1073                .filter(|_| self.row_key.is_some())
1074                .map_or(0, xrack_runtime::ListRowRenderer::scope);
1075            let expects_rows = !range.is_empty();
1076            let delegates = if let Some(renderer) = renderer {
1077                let columns = layout
1078                    .table
1079                    .as_ref()
1080                    .map_or_else(xrack_runtime::TableColumnWindow::default, |table| {
1081                        table.column_window(layout.clip_rect(table.body))
1082                    });
1083                renderer.render_in_scene(node, range, &columns)
1084            } else {
1085                component.list_rows(&self.path, range)
1086            };
1087            xrack_runtime::update_profile::rows(node.element_id(), delegates.len());
1088            let missing_list_rows = expects_rows && delegates.is_empty();
1089            node.children = delegates
1090                .into_iter()
1091                .enumerate()
1092                .map(|(slot, mut delegate)| {
1093                    let families = self.text.font_families();
1094                    if !families.is_empty()
1095                        && let Some(populated) = populate_font_choices(&delegate, families)
1096                    {
1097                        delegate = populated;
1098                    }
1099                    let mut row = Node::new("ListRow", None);
1100                    row.row_key = delegate.row_key.take();
1101                    row.row_scope = scope;
1102                    if delegate.kind == "TableRow" {
1103                        delegate.table_column_order = node.table_column_order.clone();
1104                        if row_headers {
1105                            let title = delegate.text("row-header-text").map_or_else(
1106                                || (list.first_row + slot + 1).to_string(),
1107                                str::to_owned,
1108                            );
1109                            row.properties.insert("row-header-text", title.into());
1110                        }
1111                    }
1112                    let tree_item = tree.and_then(|tree| tree.rows().get(list.first_row + slot));
1113                    if let Some(item) = tree_item {
1114                        row.properties
1115                            .insert("tree-depth", (item.depth as i64).into());
1116                        row.properties
1117                            .insert("tree-has-children", item.has_children.into());
1118                        row.properties.insert("tree-expanded", item.expanded.into());
1119                        row.properties.insert(
1120                            "tree-indentation",
1121                            xrack_runtime::Length(f64::from(indentation)).into(),
1122                        );
1123                    }
1124                    let current = selected == Some((list.first_row + slot) as i64);
1125                    let grid = selection.filter(|view| view.target() != SelectionTarget::Rows);
1126                    if let (Some(view), Some(key)) = (grid, row.row_key) {
1127                        let columns = delegate.table_column_window.clone();
1128                        for (index, cell) in delegate.children.iter_mut().enumerate() {
1129                            let column = columns.logical_index(index);
1130                            if !cell.is_visible() {
1131                                continue;
1132                            }
1133                            if view.contains_cell(key, column) {
1134                                cell.properties.insert("table-selected", true.into());
1135                            }
1136                            if current && view.current_column() == Some(column) {
1137                                cell.properties.insert("table-current", true.into());
1138                            }
1139                        }
1140                    }
1141                    let is_selected = if let Some(keys) = tree_selection {
1142                        tree_item.is_some_and(|item| {
1143                            row.row_key == Some(item.row) && keys.get(&item.key) == Some(&item.row)
1144                        })
1145                    } else {
1146                        selection.map_or(current, |view| {
1147                            row.row_key.is_some_and(|key| view.keys().contains(&key))
1148                        })
1149                    };
1150                    if matches!(node.kind, "ListView" | "GridView") && delegate.is_item_delegate() {
1151                        delegate
1152                            .properties
1153                            .entry("highlighted")
1154                            .or_insert(xrack_runtime::Value::Bool(is_selected));
1155                        if delegate.kind == "RadioButton" {
1156                            delegate
1157                                .properties
1158                                .insert("checked", xrack_runtime::Value::Bool(current));
1159                        }
1160                    }
1161                    row.properties
1162                        .insert("selected", xrack_runtime::Value::Bool(is_selected));
1163                    if (node.kind == "GridView"
1164                        || tree_selection.is_some()
1165                        || selection.is_some() && grid.is_none())
1166                        && current
1167                    {
1168                        row.properties
1169                            .insert("current", xrack_runtime::Value::Bool(true));
1170                    }
1171                    row.children.push(delegate);
1172                    row
1173                })
1174                .collect();
1175            node.list = Some(list);
1176            let (incoming_clip, incoming_shapes, incoming_space) =
1177                if let Some(placement) = &layout.transform {
1178                    (
1179                        placement.parent_clip,
1180                        layout
1181                            .ancestor_shapes
1182                            .as_ref()
1183                            .and_then(|shape| shape.parent.clone()),
1184                        placement.parent_space.clone(),
1185                    )
1186                } else {
1187                    (
1188                        layout.clip,
1189                        layout.ancestor_shapes.clone(),
1190                        layout.space.clone(),
1191                    )
1192                };
1193            let shapes = std::mem::replace(&mut self.ancestor_shapes, incoming_shapes);
1194            let space = std::mem::replace(&mut self.space, incoming_space);
1195            // Materializing row contents leaves the resolved scroll geometry intact.
1196            self.resolved_list_scroll = layout.scroll;
1197            let pane = layout.table_pane.take();
1198            *layout = self.place(
1199                node,
1200                layout.bounds,
1201                incoming_clip,
1202                layout.visible,
1203                layout.enabled,
1204                None,
1205            );
1206            layout.table_pane = pane;
1207            layout.missing_list_rows = missing_list_rows;
1208            self.ancestor_shapes = shapes;
1209            self.space = space;
1210        }
1211        self.populate_section_headers(node, layout);
1212        let columns = node.table_column_window.clone();
1213        for (index, (child, item)) in node
1214            .children
1215            .iter_mut()
1216            .zip(&mut layout.children)
1217            .enumerate()
1218        {
1219            self.path.push(columns.logical_index(index));
1220            self.populate_lists(component, child, item);
1221            layout.missing_descendant_list_rows |= item.has_missing_list_rows();
1222            self.path.pop();
1223        }
1224        if let Some((index, page)) = node
1225            .swipe_preview
1226            .as_mut()
1227            .and_then(|preview| preview.page.as_mut())
1228            && let Some(item) = &mut layout.swipe_preview
1229        {
1230            self.path.push(*index);
1231            self.populate_lists(component, page, item);
1232            self.path.pop();
1233            scroll_bar::attach(page, item, self.text);
1234        }
1235        self.row_key = previous_row;
1236        self.layout_direction = previous_direction;
1237    }
1238
1239    fn populate_section_headers(&mut self, node: &Node, layout: &mut LayoutNode) {
1240        let Some(renderer) = node
1241            .list_section_renderer
1242            .as_ref()
1243            .filter(|_| layout.visible)
1244        else {
1245            return;
1246        };
1247        let clip = layout.clip_rect(layout.bounds);
1248        let Some(headers) = layout.list_section_headers.as_deref_mut() else {
1249            return;
1250        };
1251        let previous_space = std::mem::replace(&mut self.space, layout.space.clone());
1252        let previous_shapes =
1253            std::mem::replace(&mut self.ancestor_shapes, layout.ancestor_shapes.clone());
1254        for header in headers {
1255            let visible = clip.intersect(header.bounds);
1256            if visible.width <= 0.0 || visible.height <= 0.0 {
1257                continue;
1258            }
1259            let Some(node) = renderer.render(xrack_runtime::ListSectionInput {
1260                label: header.label.clone(),
1261                first_index: header.first_row as i64,
1262                count: header.row_count as i64,
1263                pinned: header.pinned,
1264            }) else {
1265                continue;
1266            };
1267            let item = self.place(&node, header.bounds, visible, true, layout.enabled, None);
1268            header.content = Some(Box::new((node, item)));
1269        }
1270        self.space = previous_space;
1271        self.ancestor_shapes = previous_shapes;
1272    }
1273
1274    fn place(
1275        &mut self,
1276        node: &Node,
1277        bounds: Rect,
1278        clip: Rect,
1279        parent_visible: bool,
1280        parent_enabled: bool,
1281        row_children: Option<grid::RowPlacements>,
1282    ) -> LayoutNode {
1283        let outer_key = self.row_key;
1284        let outer_direction = self.layout_direction;
1285        let outer_anchor = self.anchor;
1286        let outer_shapes = self.ancestor_shapes.clone();
1287        let outer_space = self.space.clone();
1288        self.row_key = node.routing_row_key().or(outer_key);
1289        self.layout_direction = node.layout_direction().or(outer_direction);
1290        let row_cache = node.kind == "ListRow"
1291            && row_children.is_none()
1292            && self.space.is_none()
1293            && self.ancestor_shapes.is_none()
1294            && self.row_layouts.is_some();
1295        let layout = if row_cache && let Some(row) = node.routing_row_key() {
1296            let slot = row_layout::Slot { row, column: None };
1297            let inputs = row_layout::RowInputs {
1298                size: Size::new(bounds.width, bounds.height),
1299                visible: parent_visible,
1300                enabled: parent_enabled,
1301                layout_direction: self.layout_direction,
1302            };
1303            self.place_cached_content(node, bounds, clip, inputs, slot)
1304        } else {
1305            self.place_node(
1306                node,
1307                bounds,
1308                clip,
1309                parent_visible,
1310                parent_enabled,
1311                row_children,
1312            )
1313        };
1314        self.row_key = outer_key;
1315        self.layout_direction = outer_direction;
1316        self.anchor = outer_anchor;
1317        self.ancestor_shapes = outer_shapes;
1318        self.space = outer_space;
1319        layout
1320    }
1321
1322    fn place_cached_content(
1323        &mut self,
1324        node: &Node,
1325        bounds: Rect,
1326        clip: Rect,
1327        inputs: row_layout::RowInputs,
1328        slot: row_layout::Slot,
1329    ) -> LayoutNode {
1330        if self
1331            .input
1332            .is_some_and(|input| input.contains_switch_preview(&self.path))
1333        {
1334            return self.place_node(node, bounds, clip, inputs.visible, inputs.enabled, None);
1335        }
1336        let depth = if slot.column.is_some() { 3 } else { 1 };
1337        let path_len = self.path.len().saturating_sub(depth);
1338        let path = &self.path[..path_len];
1339        if let Some(mut layout) = self
1340            .row_layouts
1341            .as_deref_mut()
1342            .and_then(|cache| cache.get(path, slot, node, inputs))
1343        {
1344            row_layout::place_in_view(&mut layout, bounds, clip);
1345            return layout;
1346        }
1347        if !row_layout::cacheable(node) {
1348            return self.place_node(node, bounds, clip, inputs.visible, inputs.enabled, None);
1349        }
1350        let local = Rect::new(0.0, 0.0, inputs.size.width, inputs.size.height);
1351        let mut layout = self.place_node(node, local, local, inputs.visible, inputs.enabled, None);
1352        let path = &self.path[..path_len];
1353        if let Some(cache) = self.row_layouts.as_deref_mut() {
1354            cache.insert(path, slot, node, inputs, &layout);
1355        }
1356        row_layout::place_in_view(&mut layout, bounds, clip);
1357        layout
1358    }
1359
1360    fn place_node(
1361        &mut self,
1362        node: &Node,
1363        bounds: Rect,
1364        clip: Rect,
1365        parent_visible: bool,
1366        parent_enabled: bool,
1367        row_children: Option<grid::RowPlacements>,
1368    ) -> LayoutNode {
1369        let resolved_list_scroll = self.resolved_list_scroll.take();
1370        let tree_parts = match &row_children {
1371            Some(grid::RowPlacements::Tree {
1372                geometry,
1373                has_children,
1374            }) => Some((*geometry, *has_children)),
1375            _ => None,
1376        };
1377        let font_size = self.text.font_size(node);
1378        let children_enabled = parent_enabled && node.enables_children();
1379        let enabled =
1380            children_enabled && (node.kind != "TouchArea" || node.boolean("enabled", true));
1381        let mut visible = parent_visible
1382            && node.is_visible()
1383            && (node.kind != "PopupWindow" || enabled && self.anchor.is_some())
1384            && xrack_runtime::indicator_state(node) != Some(xrack_runtime::IndicatorState::Hidden);
1385        let (bounds, clip) = if node.kind == "Shortcut" {
1386            (Rect::new(bounds.x, bounds.y, 0.0, 0.0), clip)
1387        } else if visible
1388            && node.kind == "PopupWindow"
1389            && let Some(anchor) = self.anchor
1390        {
1391            (
1392                popup::bounds(node, anchor, self.viewport, self.text),
1393                self.viewport,
1394            )
1395        } else if visible && is_modal_overlay(node.kind) {
1396            (modal::bounds(node, self.viewport, self.text), self.viewport)
1397        } else {
1398            (bounds, clip)
1399        };
1400        if is_window_overlay(node.kind) {
1401            self.ancestor_shapes = None;
1402            self.space = None;
1403        }
1404        let local = Affine::for_node(node, bounds);
1405        let mut clip = clip;
1406        let transform = if local != Affine::IDENTITY {
1407            let parent_space = self.space.clone();
1408            let parent_clip = clip;
1409            self.ancestor_shapes = Some(Arc::new(ClipChain {
1410                shape: RoundedClip {
1411                    bounds: clip,
1412                    radii: [0.0; 4],
1413                },
1414                parent: self.ancestor_shapes.clone(),
1415                space: parent_space.clone(),
1416            }));
1417            let world = local.then(
1418                parent_space
1419                    .as_deref()
1420                    .map_or(Affine::IDENTITY, |space| space.world),
1421            );
1422            self.space = Some(Arc::new(TransformSpace {
1423                world,
1424                inverse: world.inverse(),
1425            }));
1426            clip = local
1427                .inverse()
1428                .map_or(Rect::default(), |inverse| inverse.map_rect(clip));
1429            Some(Box::new(TransformPlacement {
1430                local,
1431                parent_clip,
1432                parent_space,
1433            }))
1434        } else {
1435            None
1436        };
1437        let space = self.space.clone();
1438        let world = space
1439            .as_deref()
1440            .map_or(Affine::IDENTITY, |space| space.world);
1441        let inverse = space
1442            .as_deref()
1443            .map_or(Some(Affine::IDENTITY), |space| space.inverse);
1444        visible &= inverse.is_some();
1445        let ancestor_shapes = self.ancestor_shapes.clone();
1446        let clipped = world.map_rect(bounds.intersect(clip));
1447        let clipped = ancestor_shapes.as_deref().map_or(clipped, |chain| {
1448            chain.clip_rect(clipped, Affine::IDENTITY, Affine::IDENTITY)
1449        });
1450        if node.kind != "Shortcut" {
1451            self.anchor =
1452                (visible && clipped.width > 0.0 && clipped.height > 0.0).then_some(clipped);
1453        }
1454        if matches!(node.kind, "Menu" | "Tooltip" | "Shortcut") {
1455            // Menus and tooltips lay out their children in the overlay presenter.
1456            return LayoutNode {
1457                bounds,
1458                clip,
1459                visible: visible && node.kind != "Tooltip",
1460                enabled,
1461                layout_direction: self.layout_direction.unwrap_or_default(),
1462                direction_override: self.layout_direction,
1463                content_bounds: None,
1464                scroll: None,
1465                list_section_headers: None,
1466                horizontal_scroll: None,
1467                horizontal_scroll_reversed: false,
1468                viewport_handle: None,
1469                nested_list: None,
1470                missing_list_rows: false,
1471                missing_descendant_list_rows: false,
1472                attached_scroll_bar: None,
1473                mouse_drag_pan: false,
1474                middle_mouse_pan: false,
1475                pan_axes: [false; 2],
1476                elastic: None,
1477                table: None,
1478                split: None,
1479                tab_header: None,
1480                tab_close: None,
1481                tab_strip: None,
1482                tumbler: None,
1483                switch_position: None,
1484                swipe_delegate: None,
1485                swipe_preview: None,
1486                styled_text: None,
1487                font_size,
1488                overlays: None,
1489                paint_order: None,
1490                overflow: false,
1491                child_shape: None,
1492                ancestor_shapes,
1493                space,
1494                transform,
1495                table_pane: None,
1496                table_column_window: node.table_column_window.clone(),
1497                children: Vec::new(),
1498            };
1499        }
1500        let table = if visible && node.table_header.is_some() {
1501            TableGeometry::with_offset(
1502                node,
1503                bounds,
1504                clip,
1505                self.requested_scroll(node, Orientation::Horizontal),
1506                self.layout_direction.unwrap_or_default(),
1507            )
1508            .map(Box::new)
1509        } else {
1510            None
1511        };
1512        let pane = xrack_runtime::is_pane(node.kind);
1513        let overflow =
1514            (matches!(node.kind, "Rectangle" | "Flickable") || pane) && !node.boolean("clip", true);
1515        let clipping = ((node.kind == "Rectangle" || pane) && node.boolean("clip", false))
1516            .then(|| RoundedClip::content_box(node, bounds));
1517        let child_shape = clipping.filter(|shape| shape.radii.iter().any(|radius| *radius > 0.0));
1518        if let Some(shape) = child_shape {
1519            self.ancestor_shapes = Some(Arc::new(ClipChain {
1520                shape,
1521                parent: ancestor_shapes.clone(),
1522                space: space.clone(),
1523            }));
1524        }
1525        let viewport = table.as_ref().map_or(bounds, |table| table.rows_area());
1526        let child_clip = if overflow {
1527            clip
1528        } else {
1529            clip.intersect(clipping.map_or(viewport, |shape| shape.bounds))
1530        };
1531        if matches!(
1532            node.kind,
1533            "TabWidget" | "SwipeView" | "StackView" | "StackLayout"
1534        ) && visible
1535        {
1536            let tabs = (node.kind == "TabWidget").then(|| {
1537                selection::TabGeometry::new(
1538                    bounds,
1539                    node.orientation(),
1540                    self.layout_direction.unwrap_or_default(),
1541                )
1542            });
1543            let stack_layout = node.kind == "StackLayout";
1544            let page_bounds = if stack_layout {
1545                linear::Padding::read(node).inner_rect(bounds)
1546            } else {
1547                tabs.as_ref().map_or(bounds, |geometry| geometry.content)
1548            };
1549            let selected = if node.kind == "StackView" {
1550                node.stack_page_index()
1551            } else {
1552                group_index(node)
1553            };
1554            let orientation = node.orientation();
1555            let direction = self.layout_direction.unwrap_or_default();
1556            let headers = tabs.as_ref().map(|geometry| {
1557                let requested = self.scroll_request(node, orientation);
1558                let reveal = requested.is_none()
1559                    || self.input.is_some_and(|input| {
1560                        input.scroll_selection_changed(node, &self.path, 1, direction)
1561                    });
1562                selection::tab_bar(node, geometry.bar, self.text, direction, requested, reveal)
1563            });
1564            let header_scroll = headers.as_ref().map(|(_, scroll)| *scroll);
1565            let children = node
1566                .children
1567                .iter()
1568                .enumerate()
1569                .map(|(index, tab)| {
1570                    self.path.push(index);
1571                    let active = selected == Some(index);
1572                    let bounds = if stack_layout && active && tab.is_visible() {
1573                        let size = Size::new(page_bounds.width, page_bounds.height);
1574                        let metrics = linear::measure(tab, size, self.text);
1575                        place_in_direction(
1576                            Rect::new(
1577                                page_bounds.x,
1578                                page_bounds.y,
1579                                metrics.x.clamp(size.width),
1580                                metrics.y.clamp(size.height),
1581                            ),
1582                            page_bounds,
1583                            direction,
1584                        )
1585                    } else {
1586                        page_bounds
1587                    };
1588                    let clip = if stack_layout {
1589                        child_clip.intersect(page_bounds)
1590                    } else {
1591                        child_clip
1592                    };
1593                    let mut page = self.place(tab, bounds, clip, active, enabled, None);
1594                    self.path.pop();
1595                    if let Some((rects, _)) = &headers
1596                        && tab.is_visible()
1597                    {
1598                        page.tab_header = rects.get(index).copied();
1599                        if xrack_runtime::tab_is_closable(node, tab) {
1600                            page.tab_close = page
1601                                .tab_header
1602                                .and_then(|header| selection::tab_close_rect(header, direction));
1603                        }
1604                    }
1605                    page
1606                })
1607                .collect();
1608            let swipe_preview = node
1609                .swipe_preview
1610                .as_ref()
1611                .and_then(|preview| preview.page.as_ref())
1612                .map(|(index, page)| {
1613                    self.path.push(*index);
1614                    let item = self.place(page, page_bounds, child_clip, true, enabled, None);
1615                    self.path.pop();
1616                    Box::new(item)
1617                });
1618            return LayoutNode {
1619                bounds,
1620                clip,
1621                visible,
1622                enabled,
1623                layout_direction: self.layout_direction.unwrap_or_default(),
1624                direction_override: self.layout_direction,
1625                content_bounds: None,
1626                scroll: header_scroll.filter(|_| orientation == Orientation::Vertical),
1627                list_section_headers: None,
1628                horizontal_scroll: header_scroll.filter(|_| orientation == Orientation::Horizontal),
1629                horizontal_scroll_reversed: false,
1630                viewport_handle: None,
1631                nested_list: None,
1632                missing_list_rows: false,
1633                missing_descendant_list_rows: false,
1634                attached_scroll_bar: None,
1635                mouse_drag_pan: false,
1636                middle_mouse_pan: tabs.is_some(),
1637                pan_axes: [tabs.is_some(); 2],
1638                elastic: None,
1639                table: None,
1640                split: None,
1641                tab_header: None,
1642                tab_close: None,
1643                tab_strip: tabs.as_ref().map(|geometry| geometry.bar),
1644                tumbler: None,
1645                switch_position: None,
1646                swipe_delegate: None,
1647                swipe_preview,
1648                styled_text: None,
1649                font_size,
1650                overlays: None,
1651                paint_order: None,
1652                overflow: false,
1653                child_shape: None,
1654                ancestor_shapes,
1655                space,
1656                transform,
1657                table_pane: None,
1658                table_column_window: node.table_column_window.clone(),
1659                children,
1660            };
1661        }
1662        let mut scroll = None;
1663        let mut horizontal_scroll = None;
1664        let mut list_section_headers = None;
1665        let mut scroll_area = None;
1666        let horizontal_scroll_reversed = matches!(node.kind, "ScrollView" | "Flickable")
1667            && self.layout_direction == Some(LayoutDirection::RightToLeft);
1668        let (split, split_rects) = if visible && node.kind == "SplitView" {
1669            let (geometry, rects) = SplitGeometry::new(
1670                node,
1671                bounds,
1672                self.layout_direction.unwrap_or_default(),
1673                self.text,
1674            );
1675            (Some(Box::new(geometry)), Some(rects))
1676        } else {
1677            (None, None)
1678        };
1679        let table_cells = node.kind == "TableRow" && row_children.is_some();
1680        let mut row_children = row_children;
1681        let page = (visible && (node.kind == "Page" || node.application_window))
1682            .then(|| page::Regions::new(node, bounds, self.text));
1683        let swipe_delegate = (visible && node.kind == "SwipeDelegate").then(|| {
1684            let mut geometry = SwipeDelegateGeometry::new(node, bounds, self.text);
1685            if enabled
1686                && let Some(offset) = self.input.and_then(|input| {
1687                    input.swipe_preview_offset(&self.path, node, &geometry, self.row_key)
1688                })
1689            {
1690                geometry.set_preview(offset);
1691            }
1692            Box::new(geometry)
1693        });
1694        let switch_position = if enabled && visible && node.kind == "Switch" {
1695            self.input.and_then(|input| {
1696                input.switch_position(
1697                    node,
1698                    bounds,
1699                    self.layout_direction.unwrap_or_default(),
1700                    &self.path,
1701                    self.row_key,
1702                )
1703            })
1704        } else {
1705            None
1706        };
1707        let custom_scroll = (visible && node.has_scroll_parts() && node.scroll_target.is_none())
1708            .then(|| {
1709                scroll_bar::standalone_geometry(
1710                    node,
1711                    bounds,
1712                    self.layout_direction.unwrap_or_default(),
1713                )
1714            })
1715            .flatten();
1716        let placements = if !visible {
1717            (0..node.children.len())
1718                .map(|_| grid::Placement::plain(Rect::new(bounds.x, bounds.y, 0.0, 0.0)))
1719                .collect()
1720        } else if node.has_scroll_parts() {
1721            node.children
1722                .iter()
1723                .map(|child| {
1724                    let rect = custom_scroll.map_or_else(
1725                        || Rect::new(bounds.x, bounds.y, 0.0, 0.0),
1726                        |geometry| {
1727                            if child.kind == "ScrollThumb" {
1728                                geometry.thumb
1729                            } else {
1730                                geometry.track
1731                            }
1732                        },
1733                    );
1734                    grid::Placement::plain(rect)
1735                })
1736                .collect()
1737        } else if let Some(rects) = split_rects {
1738            rects.into_iter().map(grid::Placement::plain).collect()
1739        } else if node.kind == "MonthGrid" && node.calendar_cells().is_some() {
1740            node.children
1741                .iter()
1742                .map(|child| {
1743                    grid::Placement::plain(if child.kind == "CalendarCells" {
1744                        bounds
1745                    } else {
1746                        self.absolute_child(child, bounds)
1747                    })
1748                })
1749                .collect()
1750        } else if node.has_progress_parts() {
1751            let fill = progress_fill_bounds(
1752                bounds,
1753                self.layout_direction.unwrap_or_default(),
1754                xrack_runtime::indicator_state(node)
1755                    .unwrap_or(xrack_runtime::IndicatorState::Hidden),
1756                None,
1757            );
1758            node.children
1759                .iter()
1760                .map(|child| {
1761                    grid::Placement::plain(match child.kind {
1762                        "ProgressTrack" => bounds,
1763                        "ProgressFill" => fill,
1764                        _ => self.absolute_child(child, bounds),
1765                    })
1766                })
1767                .collect()
1768        } else if node.control_part("SliderHandle").is_some() {
1769            let geometry = SliderGeometry::with_layout_direction(
1770                bounds,
1771                node,
1772                self.layout_direction.unwrap_or_default(),
1773            );
1774            let range = xrack_runtime::SliderRange::from_node(node);
1775            let fraction = self
1776                .input
1777                .and_then(|input| {
1778                    (!node.boolean("live", true))
1779                        .then(|| input.slider_preview(&self.path))
1780                        .flatten()
1781                })
1782                .map_or_else(|| range.fraction(), |value| range.preview_fraction(value));
1783            node.children
1784                .iter()
1785                .map(|child| {
1786                    let rect = if child.kind == "SliderHandle" {
1787                        geometry.thumb_bounds(0, fraction)
1788                    } else {
1789                        self.absolute_child(child, bounds)
1790                    };
1791                    grid::Placement::plain(rect)
1792                })
1793                .collect()
1794        } else if node.kind == "ComboBox" && !node.children.is_empty() {
1795            let direction = self.layout_direction.unwrap_or_default();
1796            let geometry = ComboGeometry::for_control(node, bounds, direction);
1797            node.children
1798                .iter()
1799                .map(|child| match child.kind {
1800                    "ComboIndicator" => grid::Placement::plain(geometry.indicator_bounds(child)),
1801                    "ComboPopup" => grid::Placement::plain(Rect::new(bounds.x, bounds.y, 0.0, 0.0)),
1802                    "ComboContent" => {
1803                        let bounds = geometry.label_bounds(direction);
1804                        grid::Placement {
1805                            bounds,
1806                            clip: Some(Arc::new(table::PaneClip {
1807                                bounds,
1808                                space: space.clone(),
1809                            })),
1810                            row_children: None,
1811                        }
1812                    }
1813                    _ => grid::Placement::plain(self.absolute_child(child, bounds)),
1814                })
1815                .collect()
1816        } else if xrack_runtime::is_spin_box(node.kind) && !node.children.is_empty() {
1817            let geometry = SpinGeometry::with_layout_direction(
1818                bounds,
1819                node,
1820                self.layout_direction.unwrap_or_default(),
1821            );
1822            node.children
1823                .iter()
1824                .map(|child| {
1825                    grid::Placement::plain(match child.kind {
1826                        "SpinUpIndicator" => geometry.up,
1827                        "SpinDownIndicator" => geometry.down,
1828                        _ => self.absolute_child(child, bounds),
1829                    })
1830                })
1831                .collect()
1832        } else if node.control_part("ToggleIndicator").is_some()
1833            || node.control_part("SwitchThumb").is_some()
1834        {
1835            let geometry =
1836                ToggleGeometry::new(node, bounds, self.layout_direction.unwrap_or_default());
1837            let checked = node.boolean("checked", false);
1838            node.children
1839                .iter()
1840                .map(|child| {
1841                    grid::Placement::plain(match child.kind {
1842                        "ToggleIndicator" => geometry.indicator,
1843                        "SwitchThumb" => geometry.switch_thumb(checked, switch_position),
1844                        _ => self.absolute_child(child, bounds),
1845                    })
1846                })
1847                .collect()
1848        } else if node.control_part("ButtonContent").is_some() {
1849            let content = bounds.inset(ButtonContent::new(node).padding);
1850            node.children
1851                .iter()
1852                .map(|child| {
1853                    grid::Placement::plain(if child.kind == "ButtonContent" {
1854                        content
1855                    } else {
1856                        self.absolute_child(child, bounds)
1857                    })
1858                })
1859                .collect()
1860        } else if node.kind == "SplitHandle" {
1861            node.children
1862                .iter()
1863                .map(|_| grid::Placement::plain(bounds))
1864                .collect()
1865        } else if node.kind == "CalendarCells" {
1866            (0..node.children.len())
1867                .map(|slot| {
1868                    let bounds = calendar::month_cell(
1869                        bounds,
1870                        slot,
1871                        self.layout_direction.unwrap_or_default(),
1872                    );
1873                    grid::Placement {
1874                        bounds,
1875                        clip: Some(Arc::new(table::PaneClip {
1876                            bounds,
1877                            space: space.clone(),
1878                        })),
1879                        row_children: None,
1880                    }
1881                })
1882                .collect()
1883        } else if let Some(list) = node.list {
1884            let cells = ViewCells::new(node, viewport.width);
1885            let axis = resolved_list_scroll
1886                .unwrap_or_else(|| self.list_scroll(node, &cells, viewport.height, list.row_count));
1887            scroll = Some(axis);
1888            list_section_headers = cells.headers(viewport, axis.offset, list.row_count);
1889            let panes = table.as_ref().and_then(|table| {
1890                if table.row_header.width == 0.0 {
1891                    table.frozen_boundary()?;
1892                }
1893                let pane = |bounds| {
1894                    Arc::new(table::PaneClip {
1895                        bounds,
1896                        space: space.clone(),
1897                    })
1898                };
1899                Some((pane(table.frozen_body()), pane(table.scrollable_body())))
1900            });
1901            node.children
1902                .iter()
1903                .enumerate()
1904                .map(|(slot, row)| {
1905                    if list.row_count == 0 && row.kind == "EmptyState" {
1906                        return grid::Placement::plain(viewport);
1907                    }
1908                    let bounds = cells.bounds(list.first_row + slot, viewport, axis.offset);
1909                    let bounds = if node.kind == "GridView" {
1910                        place_in_direction(
1911                            bounds,
1912                            viewport,
1913                            self.layout_direction.unwrap_or_default(),
1914                        )
1915                    } else {
1916                        bounds
1917                    };
1918                    let delegate = if row.kind == "ListRow" {
1919                        row.children.first()
1920                    } else {
1921                        Some(row)
1922                    };
1923                    grid::Placement {
1924                        bounds,
1925                        clip: None,
1926                        row_children: table.as_ref().zip(delegate).map(|(table, row)| {
1927                            grid::RowPlacements::Cells(
1928                                row.materialized_children()
1929                                    .filter_map(|(index, _)| {
1930                                        let column = table.columns.get(index)?;
1931                                        Some(grid::CellPlacement {
1932                                            bounds: Rect::new(
1933                                                column.x,
1934                                                bounds.y,
1935                                                column.width,
1936                                                bounds.height,
1937                                            ),
1938                                            clip: panes.as_ref().map(|(frozen, scrolling)| {
1939                                                if table.is_frozen(index) {
1940                                                    frozen.clone()
1941                                                } else {
1942                                                    scrolling.clone()
1943                                                }
1944                                            }),
1945                                        })
1946                                    })
1947                                    .collect(),
1948                            )
1949                        }),
1950                    }
1951                })
1952                .collect()
1953        } else if node.kind == "RangeSlider" {
1954            let geometry = SliderGeometry::with_layout_direction(
1955                bounds,
1956                node,
1957                self.layout_direction.unwrap_or_default(),
1958            );
1959            let interval = xrack_runtime::SliderInterval::from_node(node);
1960            let preview = self
1961                .input
1962                .filter(|_| enabled)
1963                .and_then(|input| input.interval_preview(node, &self.path));
1964            let fractions = preview.map_or_else(
1965                || interval.fractions(),
1966                |(index, fraction)| interval.preview_fractions(index, fraction),
1967            );
1968            node.children
1969                .iter()
1970                .enumerate()
1971                .map(|(index, child)| {
1972                    let index = if index < Node::RANGE_THUMBS {
1973                        Some(index)
1974                    } else {
1975                        Node::RANGE_HANDLE_PARTS
1976                            .iter()
1977                            .position(|kind| *kind == child.kind)
1978                    };
1979                    let rect = index.map_or(Rect::default(), |index| {
1980                        geometry.thumb_bounds(index, fractions[index])
1981                    });
1982                    grid::Placement::plain(rect)
1983                })
1984                .collect()
1985        } else if node.kind == "ListRow" {
1986            let direction = self.layout_direction.unwrap_or_default();
1987            let tree = TreeRowGeometry::with_layout_direction(node, bounds, direction);
1988            node.children
1989                .iter()
1990                .map(|child| {
1991                    if let Some(geometry) = tree
1992                        && child.kind == "TreeRow"
1993                        && child.control_part("TreeDisclosure").is_some()
1994                    {
1995                        grid::Placement {
1996                            bounds,
1997                            clip: None,
1998                            row_children: Some(grid::RowPlacements::Tree {
1999                                geometry,
2000                                has_children: node.boolean("tree-has-children", false),
2001                            }),
2002                        }
2003                    } else {
2004                        grid::Placement {
2005                            bounds: tree.map_or(bounds, |tree| tree.content),
2006                            clip: None,
2007                            row_children: row_children.take(),
2008                        }
2009                    }
2010                })
2011                .collect()
2012        } else if node.kind == "GridLayout" {
2013            grid::children(
2014                node,
2015                bounds,
2016                self.layout_direction.unwrap_or_default(),
2017                self.text,
2018            )
2019        } else if node.kind == "TabBar" {
2020            let orientation = node.orientation();
2021            let direction = self.layout_direction.unwrap_or_default();
2022            let requested = self.scroll_request(node, orientation);
2023            let reveal = requested.is_none()
2024                || self.input.is_some_and(|input| {
2025                    input.scroll_selection_changed(node, &self.path, 1, direction)
2026                });
2027            let (rects, axis) =
2028                selection::tab_bar(node, bounds, self.text, direction, requested, reveal);
2029            match orientation {
2030                Orientation::Horizontal => horizontal_scroll = Some(axis),
2031                Orientation::Vertical => scroll = Some(axis),
2032            }
2033            rects.into_iter().map(grid::Placement::plain).collect()
2034        } else if matches!(node.kind, "ScrollView" | "Flickable") {
2035            let (rects, x, y, area) =
2036                self.scroll_view_children(node, bounds, enabled, horizontal_scroll_reversed);
2037            scroll_area = (area != bounds).then_some(area);
2038            horizontal_scroll = Some(x);
2039            scroll = Some(y);
2040            rects.into_iter().map(grid::Placement::plain).collect()
2041        } else if let Some((tree, _)) = tree_parts {
2042            node.children
2043                .iter()
2044                .map(|child| {
2045                    grid::Placement::plain(if child.kind == "TreeDisclosure" {
2046                        tree.indicator
2047                    } else {
2048                        self.absolute_child(child, tree.content)
2049                    })
2050                })
2051                .collect()
2052        } else if let Some(grid::RowPlacements::Cells(placements)) = row_children {
2053            placements
2054                .into_iter()
2055                .map(|cell| grid::Placement {
2056                    bounds: cell.bounds,
2057                    row_children: None,
2058                    clip: cell.clip,
2059                })
2060                .collect()
2061        } else {
2062            let mut content = if pane || node.kind == "Loader" {
2063                linear::Padding::read(node).inner_rect(bounds)
2064            } else {
2065                bounds
2066            };
2067            let title = (selection::radio_title_height(node, font_size)
2068                + modal::title_height(node, font_size)
2069                + group_box::title_height(node, font_size))
2070            .min(bounds.height);
2071            content.y += title;
2072            content.height -= title;
2073            let rects = if matches!(node.kind, "Loader" | "LoaderCandidate") {
2074                node.children.iter().map(|_| content).collect()
2075            } else if let Some(geometry) = &swipe_delegate {
2076                node.children
2077                    .iter()
2078                    .map(|child| geometry.region(child.kind).bounds)
2079                    .collect()
2080            } else if let Some(page) = &page {
2081                node.children
2082                    .iter()
2083                    .map(|child| {
2084                        page.band(child)
2085                            .unwrap_or_else(|| self.absolute_child(child, page.body))
2086                    })
2087                    .collect()
2088            } else if flow::uses_flow(node) {
2089                flow::children(
2090                    node,
2091                    content,
2092                    self.layout_direction.unwrap_or_default(),
2093                    self.text,
2094                )
2095            } else if let Some(axis) = linear::Axis::for_node(node) {
2096                linear::children(
2097                    node,
2098                    axis,
2099                    content,
2100                    self.layout_direction.unwrap_or_default(),
2101                    self.text,
2102                )
2103            } else {
2104                self.absolute_children(node, content)
2105            };
2106            rects.into_iter().map(grid::Placement::plain).collect()
2107        };
2108        let child_clip = scroll_area.map_or(child_clip, |area| child_clip.intersect(area));
2109        let children: Vec<_> = node
2110            .materialized_children()
2111            .filter(|_| !node.expander_collapsed())
2112            .zip(placements)
2113            .map(|((index, child), placement)| {
2114                self.path.push(index);
2115                let is_handle = child.kind == "SplitHandle";
2116                let closable = xrack_runtime::tab_is_closable(node, child);
2117                let clip = page.as_ref().map_or(child_clip, |page| {
2118                    child_clip.intersect(page.band(child).unwrap_or(page.body))
2119                });
2120                let region = swipe_delegate
2121                    .as_ref()
2122                    .map(|geometry| geometry.region(child.kind));
2123                let clip = region
2124                    .as_ref()
2125                    .map_or(clip, |region| clip.intersect(region.clip));
2126                let clip = view_cells::list_body_clip(
2127                    clip,
2128                    list_section_headers.as_deref().unwrap_or_default(),
2129                );
2130                let (clip, visible) = match tree_parts {
2131                    Some((tree, has_children)) if child.kind == "TreeDisclosure" => {
2132                        (clip.intersect(tree.indicator), visible && has_children)
2133                    }
2134                    Some((tree, _)) => (clip.intersect(tree.content), visible),
2135                    None => (clip, visible),
2136                };
2137                // The animated fill carries a local clip. Its moving viewport
2138                // intersection is applied by the renderer.
2139                let clip = if child.kind == "ProgressFill" {
2140                    placement.bounds
2141                } else {
2142                    clip
2143                };
2144                let scroll_part = Node::SCROLL_PARTS.contains(&child.kind);
2145                let clip = if scroll_part {
2146                    clip.intersect(placement.bounds)
2147                } else {
2148                    clip
2149                };
2150                let visible = visible
2151                    && (!scroll_part || custom_scroll.is_some())
2152                    && child.kind != "ComboPopup"
2153                    && !(child.kind == "ComboContent" && xrack_runtime::combo_editable(node));
2154                let outer_shapes = placement
2155                    .clip
2156                    .as_ref()
2157                    .map(|_| self.ancestor_shapes.clone());
2158                let pane = placement.clip.as_ref().map(|pane| {
2159                    let table_world = pane
2160                        .space
2161                        .as_ref()
2162                        .map_or(Affine::IDENTITY, |space| space.world);
2163                    let to_parent = self
2164                        .space
2165                        .as_ref()
2166                        .and_then(|space| space.inverse)
2167                        .map_or(table_world, |inverse| table_world.then(inverse));
2168                    if to_parent != Affine::IDENTITY {
2169                        self.ancestor_shapes = Some(Arc::new(ClipChain {
2170                            shape: RoundedClip {
2171                                bounds: pane.bounds,
2172                                radii: [0.0; 4],
2173                            },
2174                            parent: self.ancestor_shapes.clone(),
2175                            space: pane.space.clone(),
2176                        }));
2177                    }
2178                    (pane.bounds, to_parent)
2179                });
2180                let clip = pane.map_or(clip, |(bounds, to_parent)| {
2181                    clip.intersect(to_parent.map_rect(bounds))
2182                });
2183                let visible = visible
2184                    && region
2185                        .as_ref()
2186                        .is_none_or(|_| clip.width > 0.0 && clip.height > 0.0);
2187                let enabled = children_enabled
2188                    && node.group_content_enabled()
2189                    && region.is_none_or(|region| region.enabled);
2190                let mut child = if table_cells
2191                    && !child.children.is_empty()
2192                    && self.row_layouts.is_some()
2193                    && self.space.is_none()
2194                    && self.ancestor_shapes.is_none()
2195                    && child.routing_row_key().is_none()
2196                    && row_layout::cacheable(child)
2197                    && let Some(row) = self.row_key
2198                {
2199                    let outer_anchor = self.anchor;
2200                    let outer_direction = self.layout_direction;
2201                    self.layout_direction = child.layout_direction().or(outer_direction);
2202                    let inputs = row_layout::RowInputs {
2203                        size: Size::new(placement.bounds.width, placement.bounds.height),
2204                        visible,
2205                        enabled,
2206                        layout_direction: self.layout_direction,
2207                    };
2208                    let slot = row_layout::Slot {
2209                        row,
2210                        column: Some(index),
2211                    };
2212                    let child =
2213                        self.place_cached_content(child, placement.bounds, clip, inputs, slot);
2214                    self.anchor = outer_anchor;
2215                    self.layout_direction = outer_direction;
2216                    child
2217                } else {
2218                    self.place(
2219                        child,
2220                        placement.bounds,
2221                        clip,
2222                        visible,
2223                        enabled,
2224                        placement.row_children,
2225                    )
2226                };
2227                if child.visible && closable {
2228                    child.tab_close = selection::tab_close_rect(
2229                        placement.bounds,
2230                        self.layout_direction.unwrap_or_default(),
2231                    );
2232                }
2233                if let Some(shapes) = outer_shapes {
2234                    self.ancestor_shapes = shapes;
2235                }
2236                if let Some((bounds, to_parent)) = pane
2237                    && (to_parent != Affine::IDENTITY
2238                        || child.local_transform() != Affine::IDENTITY)
2239                {
2240                    child.table_pane = Some(Box::new((bounds, to_parent)));
2241                }
2242                if is_handle {
2243                    child.enabled &= split
2244                        .as_ref()
2245                        .and_then(|geometry| geometry.handle(index))
2246                        .is_some_and(SplitHandle::adjustable);
2247                }
2248                self.path.pop();
2249                child
2250            })
2251            .collect();
2252        let tumbler = (visible && matches!(node.kind, "Tumbler" | "PathView"))
2253            .then(|| {
2254                let wheel = xrack_runtime::Tumbler::from_node(node);
2255                let offset = self
2256                    .input
2257                    .map_or(0.0, |input| input.tumbler_offset(&wheel, &self.path));
2258                let mut geometry = if node.kind == "PathView" {
2259                    TumblerGeometry::along_path(
2260                        node,
2261                        &wheel,
2262                        bounds,
2263                        offset,
2264                        self.layout_direction.unwrap_or_default(),
2265                    )?
2266                } else {
2267                    TumblerGeometry::new(&wheel, bounds, offset)
2268                };
2269                if let Some(renderer) = &node.combo_option_renderer {
2270                    let clip = clip.intersect(bounds);
2271                    for row in &mut geometry.rows {
2272                        let visible = clip.intersect(row.bounds);
2273                        if visible.width <= 0.0 || visible.height <= 0.0 {
2274                            continue;
2275                        }
2276                        let mut input = wheel.option_input(
2277                            row.index,
2278                            row.label.clone(),
2279                            f64::from(row.displacement),
2280                            enabled,
2281                        );
2282                        input.progress = f64::from(row.progress);
2283                        if let Some(content) = renderer.render(input) {
2284                            let layout =
2285                                self.place(&content, row.bounds, visible, true, enabled, None);
2286                            row.content = Some(Box::new((content, layout)));
2287                        }
2288                    }
2289                }
2290                Some(Box::new(geometry))
2291            })
2292            .flatten();
2293        LayoutNode {
2294            bounds,
2295            clip,
2296            visible,
2297            enabled,
2298            layout_direction: self.layout_direction.unwrap_or_default(),
2299            direction_override: self.layout_direction,
2300            content_bounds: scroll_area
2301                .or_else(|| {
2302                    page.filter(|_| node.application_window)
2303                        .map(|page| page.body)
2304                })
2305                .map(Box::new),
2306            scroll,
2307            list_section_headers,
2308            horizontal_scroll,
2309            horizontal_scroll_reversed,
2310            viewport_handle: node.viewport_handle.clone(),
2311            nested_list: node
2312                .list_row_renderer
2313                .clone()
2314                .filter(|_| self.row_key.is_some()),
2315            missing_list_rows: false,
2316            missing_descendant_list_rows: false,
2317            attached_scroll_bar: None,
2318            mouse_drag_pan: node.boolean("mouse-drag-pan-enabled", node.kind == "Flickable"),
2319            middle_mouse_pan: node.kind != "Flickable"
2320                || node.boolean("mouse-drag-pan-enabled", true),
2321            pan_axes: if node.kind == "Flickable" {
2322                let direction = match node.properties.get("flick-direction") {
2323                    Some(xrack_runtime::Value::FlickDirection(direction)) => *direction,
2324                    _ => xrack_runtime::FlickDirection::Both,
2325                };
2326                [Orientation::Horizontal, Orientation::Vertical]
2327                    .map(|axis| node.boolean("interactive", true) && direction.allows(axis))
2328            } else {
2329                [true; 2]
2330            },
2331            elastic: overscroll::ElasticOptions::from_node(node),
2332            table,
2333            split,
2334            tab_header: None,
2335            tab_close: None,
2336            tab_strip: None,
2337            tumbler,
2338            switch_position,
2339            swipe_delegate,
2340            swipe_preview: None,
2341            styled_text: if visible && node.kind == "StyledText" {
2342                self.text
2343                    .layout_styled_text(node, Size::new(bounds.width, bounds.height))
2344                    .map(|mut plan| {
2345                        if let Some(direction) = self.layout_direction {
2346                            plan.align_in_direction(node, bounds.width, direction);
2347                        }
2348                        Box::new(plan)
2349                    })
2350            } else {
2351                None
2352            },
2353            font_size,
2354            overlays: None,
2355            paint_order: sibling_paint_order(node, children.len()),
2356            overflow,
2357            child_shape,
2358            ancestor_shapes,
2359            space,
2360            transform,
2361            table_pane: None,
2362            table_column_window: node.table_column_window.clone(),
2363            children,
2364        }
2365    }
2366
2367    fn list_scroll(
2368        &self,
2369        node: &Node,
2370        cells: &ViewCells,
2371        height: f32,
2372        rows: usize,
2373    ) -> ScrollLayout {
2374        let requested = self.scroll_request(node, Orientation::Vertical);
2375        let axis = ScrollLayout::new(requested.unwrap_or_default(), cells.extent(rows) - height);
2376        if node
2377            .viewport_handle
2378            .as_ref()
2379            .is_some_and(|handle| handle.has_bound_offset(Orientation::Vertical))
2380        {
2381            return axis;
2382        }
2383        let nested = node
2384            .list_row_renderer
2385            .as_ref()
2386            .filter(|_| self.row_key.is_some());
2387        let anchor = self
2388            .input
2389            .and_then(|input| {
2390                list_anchor::ListAnchor::find(
2391                    &input.scroll_anchors,
2392                    &self.path,
2393                    nested.map(xrack_runtime::ListRowRenderer::scope),
2394                )
2395            })
2396            .filter(|_| {
2397                node.boolean("preserve-scroll-anchor", false) && !self.tree_root_changed(node)
2398            });
2399        if node.boolean(
2400            "follow-current",
2401            matches!(node.kind, "StandardListView" | "GridView"),
2402        ) && let Some(index) = input::scroll_selection(node)
2403            && anchor.map_or_else(
2404                || {
2405                    requested.is_none()
2406                        || if let Some(renderer) = nested {
2407                            renderer.selection_changed(input::scroll_selection(node), cells.columns)
2408                        } else {
2409                            self.input.is_some_and(|input| {
2410                                input.scroll_selection_changed(
2411                                    node,
2412                                    &self.path,
2413                                    cells.columns,
2414                                    self.layout_direction.unwrap_or_default(),
2415                                )
2416                            })
2417                        }
2418                },
2419                |anchor| anchor.selection_changed(node),
2420            )
2421        {
2422            return cells.reveal(axis, index, height);
2423        }
2424        anchor
2425            .and_then(|anchor| anchor.restore(node, cells, requested.unwrap_or_default()))
2426            .map_or(axis, |offset| ScrollLayout::new(offset, axis.max_offset))
2427    }
2428
2429    fn scroll_view_children(
2430        &mut self,
2431        node: &Node,
2432        viewport: Rect,
2433        enabled: bool,
2434        horizontal_reversed: bool,
2435    ) -> (Vec<Rect>, ScrollLayout, ScrollLayout, Rect) {
2436        let (viewport, ScrollContent { extent, children }) =
2437            self.fit_scroll_content(node, viewport, horizontal_reversed);
2438        let horizontal = ScrollLayout::new(
2439            self.requested_scroll(node, Orientation::Horizontal),
2440            extent.width - viewport.width,
2441        );
2442        let vertical = ScrollLayout::new(
2443            self.requested_scroll(node, Orientation::Vertical),
2444            extent.height - viewport.height,
2445        );
2446        let elastic_offset = |axis| {
2447            if !enabled
2448                || !node.boolean("interactive", true)
2449                || matches!(node.properties.get("flick-direction"), Some(xrack_runtime::Value::FlickDirection(direction)) if !direction.allows(axis))
2450                || !overscroll::ElasticOptions::from_node(node)
2451                    .is_some_and(overscroll::ElasticOptions::moves_contents)
2452            {
2453                return 0.0;
2454            }
2455            let offset = self
2456                .input
2457                .zip(node.viewport_handle.as_ref())
2458                .map_or(0.0, |(input, handle)| input.visual_overscroll(handle, axis));
2459            let (scroll, logical_offset) = if axis == Orientation::Horizontal {
2460                (
2461                    horizontal,
2462                    if horizontal_reversed { -offset } else { offset },
2463                )
2464            } else {
2465                (vertical, offset)
2466            };
2467            if scroll.max_offset > 0.0
2468                && ((logical_offset < 0.0 && scroll.offset == 0.0)
2469                    || (logical_offset > 0.0 && scroll.offset == scroll.max_offset))
2470            {
2471                offset
2472            } else {
2473                0.0
2474            }
2475        };
2476        let physical_x = if horizontal_reversed {
2477            horizontal.max_offset - horizontal.offset
2478        } else {
2479            horizontal.offset
2480        };
2481        let origin = Point {
2482            x: viewport.x - physical_x - elastic_offset(Orientation::Horizontal),
2483            y: viewport.y - vertical.offset - elastic_offset(Orientation::Vertical),
2484        };
2485        let rects = node
2486            .children
2487            .iter()
2488            .zip(children)
2489            .map(|(child, placement)| {
2490                let Some((x, y, width, height)) = placement else {
2491                    return Rect::new(origin.x, origin.y, 0.0, 0.0);
2492                };
2493                let height = absolute_height(child, height, (extent.height - y.max(0.0)).max(0.0));
2494                Rect::new(origin.x + x, origin.y + y, width, height)
2495            })
2496            .collect();
2497        (rects, horizontal, vertical, viewport)
2498    }
2499
2500    fn measure_scroll_content(&mut self, node: &Node, viewport: Rect) -> ScrollContent {
2501        // Keep percentage constraints tied to the viewport or explicit content size,
2502        // so an overflowing child cannot enlarge its own percentage reference.
2503        let explicit_width = node.relative_length("content-width", viewport.width);
2504        let explicit_height = node
2505            .relative_length("content-height", viewport.height)
2506            .or_else(|| node.length("viewport-height"));
2507        let reference = Size::new(
2508            viewport.width.max(explicit_width.unwrap_or(0.0)),
2509            viewport.height.max(explicit_height.unwrap_or(0.0)),
2510        );
2511        let mut extent = reference;
2512        let mut children = Vec::with_capacity(node.children.len());
2513        for child in &node.children {
2514            if !participates_in_flow(child) {
2515                children.push(None);
2516                continue;
2517            }
2518            let x = child.length("x").unwrap_or(0.0);
2519            let y = child.length("y").unwrap_or(0.0);
2520            let metrics = linear::measure(child, reference, self.text);
2521            let width = absolute_width(child, metrics.x, (reference.width - x.max(0.0)).max(0.0));
2522            let height = linear::measure_with_width(child, reference, Some(width), self.text).y;
2523            extent.width = extent.width.max(x + width);
2524            extent.height = extent.height.max(y + height.preferred);
2525            children.push(Some((x, y, width, height)));
2526        }
2527        if node.kind == "Flickable" {
2528            extent.width = explicit_width.unwrap_or(extent.width).max(0.0);
2529            extent.height = explicit_height.unwrap_or(extent.height).max(0.0);
2530        }
2531        ScrollContent { extent, children }
2532    }
2533
2534    fn fit_scroll_content(
2535        &mut self,
2536        node: &Node,
2537        bounds: Rect,
2538        mirrored: bool,
2539    ) -> (Rect, ScrollContent) {
2540        use xrack_runtime::ScrollBarPolicy;
2541
2542        if node.kind != "ScrollView" || !node.boolean("reserve-scroll-bar-space", false) {
2543            return (bounds, self.measure_scroll_content(node, bounds));
2544        }
2545        let thickness = scroll_bar::scroll_bar_thickness(bounds);
2546        if thickness < 1.0 {
2547            return (bounds, self.measure_scroll_content(node, bounds));
2548        }
2549        let policies = [Orientation::Horizontal, Orientation::Vertical]
2550            .map(|axis| node.scroll_bar_policy(axis));
2551        let mut fallback = None;
2552        // Trying the smallest sets first handles width-sensitive content as well
2553        // as the common case where reserving one bar makes the other necessary.
2554        for bars in [[false, false], [false, true], [true, false], [true, true]] {
2555            if !bars
2556                .iter()
2557                .zip(policies)
2558                .all(|(&shown, policy)| match policy {
2559                    ScrollBarPolicy::AlwaysOn => shown,
2560                    ScrollBarPolicy::AlwaysOff => !shown,
2561                    ScrollBarPolicy::AsNeeded => true,
2562                })
2563            {
2564                continue;
2565            }
2566            let bottom = if bars[0] { thickness } else { 0.0 };
2567            let side = if bars[1] { thickness } else { 0.0 };
2568            let viewport = Rect::new(
2569                bounds.x + if mirrored { side } else { 0.0 },
2570                bounds.y,
2571                bounds.width - side,
2572                bounds.height - bottom,
2573            );
2574            let content = self.measure_scroll_content(node, viewport);
2575            let overflowing = [
2576                content.extent.width > viewport.width,
2577                content.extent.height > viewport.height,
2578            ];
2579            if bars
2580                .into_iter()
2581                .zip(policies)
2582                .zip(overflowing)
2583                .all(|((shown, policy), overflow)| {
2584                    policy != ScrollBarPolicy::AsNeeded || shown == overflow
2585                })
2586            {
2587                return (viewport, content);
2588            }
2589            fallback = Some((viewport, content));
2590        }
2591        // If responsive content oscillates between two bar sets, keep the
2592        // gutters permitted by policy and give the view a stable area.
2593        #[expect(
2594            clippy::expect_used,
2595            reason = "enumeration always includes the allowed combination of forced and optional scrollbars"
2596        )]
2597        fallback.expect("scrollbar policies allow a candidate")
2598    }
2599
2600    fn absolute_children(&mut self, node: &Node, content: Rect) -> Vec<Rect> {
2601        node.children
2602            .iter()
2603            .map(|child| self.absolute_child(child, content))
2604            .collect()
2605    }
2606
2607    fn absolute_child(&mut self, child: &Node, content: Rect) -> Rect {
2608        if !participates_in_flow(child) {
2609            return Rect::new(content.x, content.y, 0.0, 0.0);
2610        }
2611        let available = Size::new(content.width, content.height);
2612        let metrics = linear::measure(child, available, self.text);
2613        let width = absolute_width(child, metrics.x, content.width);
2614        let height = absolute_height(child, metrics.y, content.height);
2615        Rect::new(
2616            content.x + child.length("x").unwrap_or(0.0),
2617            content.y + child.length("y").unwrap_or(0.0),
2618            width,
2619            height,
2620        )
2621    }
2622}
2623
2624fn absolute_width(node: &Node, info: linear::AxisInfo, available: f32) -> f32 {
2625    if xrack_runtime::is_button(node.kind)
2626        || xrack_runtime::is_pane(node.kind)
2627        || matches!(
2628            node.kind,
2629            "Image" | "AnimatedImage" | "ToolSeparator" | "Loader"
2630        )
2631        || node.properties.contains_key("preferred-width")
2632    {
2633        info.preferred
2634    } else {
2635        info.clamp(available)
2636    }
2637}
2638
2639fn absolute_height(node: &Node, info: linear::AxisInfo, available: f32) -> f32 {
2640    if linear::intrinsic_item(node.kind)
2641        || matches!(node.kind, "ToolSeparator" | "Loader")
2642        || xrack_runtime::is_pane(node.kind)
2643        || node.properties.contains_key("preferred-height")
2644    {
2645        info.preferred
2646    } else {
2647        info.clamp(available)
2648    }
2649}