1mod 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 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 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 pub tab_header: Option<Rect>,
219 pub tab_close: Option<Rect>,
221 tab_strip: Option<Rect>,
222 pub tumbler: Option<Box<TumblerGeometry>>,
223 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#[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 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 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 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 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 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 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 pub fn dialog_paths(&self) -> &[Vec<usize>] {
521 self.overlays
522 .as_ref()
523 .map_or(&[], |overlays| overlays.modal.as_slice())
524 }
525
526 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 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 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#[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#[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
711pub 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
749pub 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#[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
841pub 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 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 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 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 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 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 #[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}