From 8b7f5e1089393b511a6e39c6134c9a55bd2a4d06 Mon Sep 17 00:00:00 2001 From: TBX3D <88289044+TBX3D@users.noreply.github.com> Date: Sun, 21 Jun 2026 14:16:14 -0700 Subject: [PATCH 1/3] feat(torin): Add reverse directions Add `Direction::HorizontalReverse` and `Direction::VerticalReverse`, which stack children along the same axis in reverse order so a layout can be reversed without reordering its children. --- .../src/resizable_container.rs | 14 +- .../src/scrollviews/use_scroll_controller.rs | 8 +- .../src/scrollviews/virtual_scrollview.rs | 8 +- crates/freya-core/src/elements/extensions.rs | 12 + crates/torin/src/geometry.rs | 4 +- crates/torin/src/measure.rs | 21 +- crates/torin/src/values/direction.rs | 21 ++ crates/torin/tests/direction.rs | 206 ++++++++++++++++++ 8 files changed, 268 insertions(+), 26 deletions(-) create mode 100644 crates/torin/tests/direction.rs diff --git a/crates/freya-components/src/resizable_container.rs b/crates/freya-components/src/resizable_container.rs index 7df997995..d8f888ab8 100644 --- a/crates/freya-components/src/resizable_container.rs +++ b/crates/freya-components/src/resizable_container.rs @@ -421,8 +421,8 @@ impl Component for ResizablePanel { let main_size = sizing.to_layout_size(size); let (width, height) = match registry.direction { - Direction::Horizontal => (main_size, Size::fill()), - Direction::Vertical => (Size::fill(), main_size), + Direction::Horizontal | Direction::HorizontalReverse => (main_size, Size::fill()), + Direction::Vertical | Direction::VerticalReverse => (Size::fill(), main_size), }; rect() @@ -492,7 +492,7 @@ impl Component for ResizableHandle { }); let cursor = match direction { - Direction::Horizontal => CursorIcon::ColResize, + Direction::Horizontal | Direction::HorizontalReverse => CursorIcon::ColResize, _ => CursorIcon::RowResize, }; @@ -524,10 +524,10 @@ impl Component for ResizableHandle { let mut registry = registry.write(); let (pixel_displacement, container_axis_size) = match registry.direction { - Direction::Horizontal => { + Direction::Horizontal | Direction::HorizontalReverse => { (coords.x as f32 - handle.min_x(), container.width()) } - Direction::Vertical => { + Direction::Vertical | Direction::VerticalReverse => { (coords.y as f32 - handle.min_y(), container.height()) } }; @@ -562,8 +562,8 @@ impl Component for ResizableHandle { let handle_size = Size::px(ResizableContext::HANDLE_SIZE); let (width, height) = match direction { - Direction::Horizontal => (handle_size, Size::fill()), - Direction::Vertical => (Size::fill(), handle_size), + Direction::Horizontal | Direction::HorizontalReverse => (handle_size, Size::fill()), + Direction::Vertical | Direction::VerticalReverse => (Size::fill(), handle_size), }; let background = match *status.read() { diff --git a/crates/freya-components/src/scrollviews/use_scroll_controller.rs b/crates/freya-components/src/scrollviews/use_scroll_controller.rs index 04f3e8531..00d970d03 100644 --- a/crates/freya-components/src/scrollviews/use_scroll_controller.rs +++ b/crates/freya-components/src/scrollviews/use_scroll_controller.rs @@ -90,21 +90,21 @@ impl ScrollController { match request { ScrollRequest { position: ScrollPosition::Start, - direction: Direction::Vertical, + direction: Direction::Vertical | Direction::VerticalReverse, .. } => { self.on_scroll.write().call(ScrollEvent::Y(0)); } ScrollRequest { position: ScrollPosition::Start, - direction: Direction::Horizontal, + direction: Direction::Horizontal | Direction::HorizontalReverse, .. } => { self.on_scroll.write().call(ScrollEvent::X(0)); } ScrollRequest { position: ScrollPosition::End, - direction: Direction::Vertical, + direction: Direction::Vertical | Direction::VerticalReverse, init, .. } => { @@ -118,7 +118,7 @@ impl ScrollController { } ScrollRequest { position: ScrollPosition::End, - direction: Direction::Horizontal, + direction: Direction::Horizontal | Direction::HorizontalReverse, init, .. } => { diff --git a/crates/freya-components/src/scrollviews/virtual_scrollview.rs b/crates/freya-components/src/scrollviews/virtual_scrollview.rs index d7119e8e8..511e23d07 100644 --- a/crates/freya-components/src/scrollviews/virtual_scrollview.rs +++ b/crates/freya-components/src/scrollviews/virtual_scrollview.rs @@ -274,11 +274,11 @@ impl Element + 'static> Component let drag_scrolling = self.drag_scrolling; let (inner_width, inner_height) = match direction { - Direction::Vertical => ( + Direction::Vertical | Direction::VerticalReverse => ( size.read().inner_sizes.width, self.item_size * self.length as f32, ), - Direction::Horizontal => ( + Direction::Horizontal | Direction::HorizontalReverse => ( self.item_size * self.length as f32, size.read().inner_sizes.height, ), @@ -500,14 +500,14 @@ impl Element + 'static> Component .collect::>(); let (offset_x, offset_y) = match direction { - Direction::Vertical => { + Direction::Vertical | Direction::VerticalReverse => { let offset_y_min = (-corrected_scrolled_y / self.item_size).floor() * self.item_size; let offset_y = -(-corrected_scrolled_y - offset_y_min); (corrected_scrolled_x, offset_y) } - Direction::Horizontal => { + Direction::Horizontal | Direction::HorizontalReverse => { let offset_x_min = (-corrected_scrolled_x / self.item_size).floor() * self.item_size; let offset_x = -(-corrected_scrolled_x - offset_x_min); diff --git a/crates/freya-core/src/elements/extensions.rs b/crates/freya-core/src/elements/extensions.rs index 6fbda8220..b5c943179 100644 --- a/crates/freya-core/src/elements/extensions.rs +++ b/crates/freya-core/src/elements/extensions.rs @@ -521,6 +521,18 @@ where self.get_layout().layout.direction = Direction::horizontal(); self } + + /// Stack children vertically in reverse order. Shorthand for [`direction`](Self::direction) set to [`Direction::VerticalReverse`]. + fn vertical_reverse(mut self) -> Self { + self.get_layout().layout.direction = Direction::vertical_reverse(); + self + } + + /// Stack children horizontally in reverse order. Shorthand for [`direction`](Self::direction) set to [`Direction::HorizontalReverse`]. + fn horizontal_reverse(mut self) -> Self { + self.get_layout().layout.direction = Direction::horizontal_reverse(); + self + } } /// Methods for setting an element's width and height. diff --git a/crates/torin/src/geometry.rs b/crates/torin/src/geometry.rs index 680e183db..c6fe7fb1b 100644 --- a/crates/torin/src/geometry.rs +++ b/crates/torin/src/geometry.rs @@ -221,11 +221,11 @@ fn calculate_extreme_corners(area: &Area, center: Point2D) -> (Point2D, Point2D) impl AlignAxis { pub fn new(direction: &Direction, alignment_direction: AlignmentDirection) -> Self { match direction { - Direction::Vertical => match alignment_direction { + Direction::Vertical | Direction::VerticalReverse => match alignment_direction { AlignmentDirection::Main => AlignAxis::Height, AlignmentDirection::Cross => AlignAxis::Width, }, - Direction::Horizontal => match alignment_direction { + Direction::Horizontal | Direction::HorizontalReverse => match alignment_direction { AlignmentDirection::Main => AlignAxis::Width, AlignmentDirection::Cross => AlignAxis::Height, }, diff --git a/crates/torin/src/measure.rs b/crates/torin/src/measure.rs index 0dbd1a7c9..fa7c4e89b 100644 --- a/crates/torin/src/measure.rs +++ b/crates/torin/src/measure.rs @@ -543,7 +543,10 @@ where // Parent Node is dirty. parent_is_dirty: bool, ) { - let children = self.tree_adapter.children_of(parent_node_id); + let mut children = self.tree_adapter.children_of(parent_node_id); + if parent_node.direction.is_reverse() { + children.reverse(); + } let initial_area = *inner_area; @@ -643,12 +646,12 @@ where if parent_node.content.is_flex() { match parent_node.direction { - Direction::Vertical => { + Direction::Vertical | Direction::VerticalReverse => { if let Some(ff) = child_data.height.flex_grow() { initial_phase_flex_grows.insert(*child_id, ff); } } - Direction::Horizontal => { + Direction::Horizontal | Direction::HorizontalReverse => { if let Some(ff) = child_data.width.flex_grow() { initial_phase_flex_grows.insert(*child_id, ff); } @@ -947,7 +950,7 @@ where ) { if let Some(initial_phase_size) = initial_phase_size { match direction { - Direction::Vertical => { + Direction::Vertical | Direction::VerticalReverse => { if adapted_available_area.height() - initial_phase_size.height < 0. { let advance = inner_sizes.width + wrap_spacing; available_area.origin.y = initial_available_area.origin.y; @@ -959,7 +962,7 @@ where parent_area.size.width += advance; } } - Direction::Horizontal => { + Direction::Horizontal | Direction::HorizontalReverse => { if adapted_available_area.width() - initial_phase_size.width < 0. { let advance = inner_sizes.height + wrap_spacing; available_area.origin.x = initial_available_area.origin.x; @@ -1095,7 +1098,7 @@ where }; match parent_node.direction { - Direction::Horizontal => { + Direction::Horizontal | Direction::HorizontalReverse => { // Move the available area available_area.origin.x = child_area.max_x() + spacing.get(); available_area.size.width -= child_area.size.width + spacing.get(); @@ -1124,7 +1127,7 @@ where parent_area.size.width += child_area.size.width + spacing.get(); } } - Direction::Vertical => { + Direction::Vertical | Direction::VerticalReverse => { // Move the available area available_area.origin.y = child_area.max_y() + spacing.get(); available_area.size.height -= child_area.size.height + spacing.get(); @@ -1182,11 +1185,11 @@ where let axis = AlignAxis::new(&parent_node.direction, alignment_direction); let (is_vertical_not_start, is_horizontal_not_start) = match parent_node.direction { - Direction::Vertical => ( + Direction::Vertical | Direction::VerticalReverse => ( parent_node.main_alignment.is_not_start(), parent_node.cross_alignment.is_not_start() || parent_node.content.is_fit(), ), - Direction::Horizontal => ( + Direction::Horizontal | Direction::HorizontalReverse => ( parent_node.cross_alignment.is_not_start() || parent_node.content.is_fit(), parent_node.main_alignment.is_not_start(), ), diff --git a/crates/torin/src/values/direction.rs b/crates/torin/src/values/direction.rs index d11949832..73736b12e 100644 --- a/crates/torin/src/values/direction.rs +++ b/crates/torin/src/values/direction.rs @@ -5,6 +5,10 @@ pub enum Direction { #[default] Vertical, Horizontal, + /// Stack children vertically, in reverse order. + VerticalReverse, + /// Stack children horizontally, in reverse order. + HorizontalReverse, } impl Direction { @@ -18,10 +22,27 @@ impl Direction { Direction::Horizontal } + /// Use a [`VerticalReverse`](Direction::VerticalReverse) direction. + pub fn vertical_reverse() -> Direction { + Direction::VerticalReverse + } + + /// Use a [`HorizontalReverse`](Direction::HorizontalReverse) direction. + pub fn horizontal_reverse() -> Direction { + Direction::HorizontalReverse + } + + /// Whether children are stacked in reverse order. + pub fn is_reverse(&self) -> bool { + matches!(self, Self::VerticalReverse | Self::HorizontalReverse) + } + pub fn pretty(&self) -> String { match self { Self::Horizontal => "horizontal".to_string(), Self::Vertical => "vertical".to_string(), + Self::HorizontalReverse => "horizontal-reverse".to_string(), + Self::VerticalReverse => "vertical-reverse".to_string(), } } } diff --git a/crates/torin/tests/direction.rs b/crates/torin/tests/direction.rs new file mode 100644 index 000000000..2521f49e2 --- /dev/null +++ b/crates/torin/tests/direction.rs @@ -0,0 +1,206 @@ +use torin::{ + prelude::*, + test_utils::*, +}; + +fn stacked_tree(parent: Node) -> (Torin, Option, TestingTree) { + let (layout, measurer) = test_utils(); + + let mut mocked_tree = TestingTree::default(); + mocked_tree.add(0, None, vec![1, 2, 3], parent); + for id in 1..=3 { + mocked_tree.add( + id, + Some(0), + vec![], + Node::from_size_and_direction( + Size::Pixels(Length::new(100.0)), + Size::Pixels(Length::new(100.0)), + Direction::Vertical, + ), + ); + } + + (layout, measurer, mocked_tree) +} + +fn leaf(width: f32) -> Node { + Node::from_size_and_direction( + Size::Pixels(Length::new(width)), + Size::Pixels(Length::new(100.0)), + Direction::Vertical, + ) +} + +#[test] +pub fn horizontal_reverse_stacks_children_in_reverse_order() { + let (mut layout, mut measurer, mut mocked_tree) = stacked_tree(Node::from_size_and_direction( + Size::Pixels(Length::new(300.0)), + Size::Pixels(Length::new(100.0)), + Direction::HorizontalReverse, + )); + + layout.measure( + 0, + Rect::new(Point2D::new(0.0, 0.0), Size2D::new(300.0, 100.0)), + &mut measurer, + &mut mocked_tree, + ); + + // The last child is placed first, so the first child ends up at the far end. + assert_eq!(layout.get(&3).unwrap().area.origin, Point2D::new(0.0, 0.0)); + assert_eq!( + layout.get(&2).unwrap().area.origin, + Point2D::new(100.0, 0.0) + ); + assert_eq!( + layout.get(&1).unwrap().area.origin, + Point2D::new(200.0, 0.0) + ); +} + +#[test] +pub fn vertical_reverse_stacks_children_in_reverse_order() { + let (mut layout, mut measurer, mut mocked_tree) = stacked_tree(Node::from_size_and_direction( + Size::Pixels(Length::new(100.0)), + Size::Pixels(Length::new(300.0)), + Direction::VerticalReverse, + )); + + layout.measure( + 0, + Rect::new(Point2D::new(0.0, 0.0), Size2D::new(100.0, 300.0)), + &mut measurer, + &mut mocked_tree, + ); + + assert_eq!(layout.get(&3).unwrap().area.origin, Point2D::new(0.0, 0.0)); + assert_eq!( + layout.get(&2).unwrap().area.origin, + Point2D::new(0.0, 100.0) + ); + assert_eq!( + layout.get(&1).unwrap().area.origin, + Point2D::new(0.0, 200.0) + ); +} + +#[test] +pub fn reverse_composes_with_center_alignment() { + let (mut layout, mut measurer) = test_utils(); + + let mut mocked_tree = TestingTree::default(); + mocked_tree.add( + 0, + None, + vec![1, 2], + Node::from_size_and_alignments_and_direction( + Size::Pixels(Length::new(300.0)), + Size::Pixels(Length::new(100.0)), + Alignment::Center, + Alignment::Start, + Direction::HorizontalReverse, + ), + ); + for id in 1..=2 { + mocked_tree.add( + id, + Some(0), + vec![], + Node::from_size_and_direction( + Size::Pixels(Length::new(50.0)), + Size::Pixels(Length::new(50.0)), + Direction::Vertical, + ), + ); + } + + layout.measure( + 0, + Rect::new(Point2D::new(0.0, 0.0), Size2D::new(300.0, 100.0)), + &mut measurer, + &mut mocked_tree, + ); + + // The 100px wide block is centered (origin x = 100), with the children reversed inside it. + assert_eq!( + layout.get(&2).unwrap().area.origin, + Point2D::new(100.0, 0.0) + ); + assert_eq!( + layout.get(&1).unwrap().area.origin, + Point2D::new(150.0, 0.0) + ); +} + +#[test] +pub fn reverse_keeps_spacing_between_children() { + let (mut layout, mut measurer, mut mocked_tree) = + stacked_tree(Node::from_size_and_alignments_and_direction_and_spacing( + Size::Pixels(Length::new(320.0)), + Size::Pixels(Length::new(100.0)), + Alignment::Start, + Alignment::Start, + Direction::HorizontalReverse, + Length::new(10.0), + )); + + layout.measure( + 0, + Rect::new(Point2D::new(0.0, 0.0), Size2D::new(320.0, 100.0)), + &mut measurer, + &mut mocked_tree, + ); + + assert_eq!(layout.get(&3).unwrap().area.origin, Point2D::new(0.0, 0.0)); + assert_eq!( + layout.get(&2).unwrap().area.origin, + Point2D::new(110.0, 0.0) + ); + assert_eq!( + layout.get(&1).unwrap().area.origin, + Point2D::new(220.0, 0.0) + ); +} + +#[test] +pub fn reverse_composes_with_flex() { + let (mut layout, mut measurer) = test_utils(); + + let mut mocked_tree = TestingTree::default(); + let mut root = Node::from_size_and_content( + Size::Pixels(Length::new(300.0)), + Size::Pixels(Length::new(100.0)), + Content::Flex, + ); + root.direction = Direction::HorizontalReverse; + mocked_tree.add(0, None, vec![1, 2, 3], root); + mocked_tree.add(1, Some(0), vec![], leaf(50.0)); + mocked_tree.add( + 2, + Some(0), + vec![], + Node::from_size_and_direction( + Size::Flex(Length::new(1.0)), + Size::Pixels(Length::new(100.0)), + Direction::Vertical, + ), + ); + mocked_tree.add(3, Some(0), vec![], leaf(50.0)); + + layout.measure( + 0, + Rect::new(Point2D::new(0.0, 0.0), Size2D::new(300.0, 100.0)), + &mut measurer, + &mut mocked_tree, + ); + + // The flex child still grows to the leftover 200px; only the order is reversed. + assert_eq!(layout.get(&3).unwrap().area.origin, Point2D::new(0.0, 0.0)); + assert_eq!(layout.get(&2).unwrap().area.width(), 200.0); + assert_eq!(layout.get(&2).unwrap().area.origin, Point2D::new(50.0, 0.0)); + assert_eq!( + layout.get(&1).unwrap().area.origin, + Point2D::new(250.0, 0.0) + ); +} From 89d7654d114395438e1b164086fa35541dbe1cb4 Mon Sep 17 00:00:00 2001 From: Marc Espin Date: Wed, 24 Jun 2026 16:09:47 +0200 Subject: [PATCH 2/3] change to order attribute --- .../src/resizable_container.rs | 14 ++--- .../src/scrollviews/use_scroll_controller.rs | 8 +-- .../src/scrollviews/virtual_scrollview.rs | 8 +-- crates/freya-core/src/elements/extensions.rs | 31 ++++++---- .../src/components/attribute.rs | 1 + crates/freya-devtools/src/node_info.rs | 3 + crates/freya/src/lib.rs | 1 + crates/torin/src/geometry.rs | 4 +- crates/torin/src/measure.rs | 18 +++--- crates/torin/src/node.rs | 5 ++ crates/torin/src/values/direction.rs | 21 ------- crates/torin/src/values/mod.rs | 2 + crates/torin/src/values/order.rs | 33 +++++++++++ crates/torin/tests/{direction.rs => order.rs} | 58 ++++++++++--------- examples/layout_reverse_direction.rs | 58 +++++++++++++++++++ 15 files changed, 180 insertions(+), 85 deletions(-) create mode 100644 crates/torin/src/values/order.rs rename crates/torin/tests/{direction.rs => order.rs} (79%) create mode 100644 examples/layout_reverse_direction.rs diff --git a/crates/freya-components/src/resizable_container.rs b/crates/freya-components/src/resizable_container.rs index d8f888ab8..7df997995 100644 --- a/crates/freya-components/src/resizable_container.rs +++ b/crates/freya-components/src/resizable_container.rs @@ -421,8 +421,8 @@ impl Component for ResizablePanel { let main_size = sizing.to_layout_size(size); let (width, height) = match registry.direction { - Direction::Horizontal | Direction::HorizontalReverse => (main_size, Size::fill()), - Direction::Vertical | Direction::VerticalReverse => (Size::fill(), main_size), + Direction::Horizontal => (main_size, Size::fill()), + Direction::Vertical => (Size::fill(), main_size), }; rect() @@ -492,7 +492,7 @@ impl Component for ResizableHandle { }); let cursor = match direction { - Direction::Horizontal | Direction::HorizontalReverse => CursorIcon::ColResize, + Direction::Horizontal => CursorIcon::ColResize, _ => CursorIcon::RowResize, }; @@ -524,10 +524,10 @@ impl Component for ResizableHandle { let mut registry = registry.write(); let (pixel_displacement, container_axis_size) = match registry.direction { - Direction::Horizontal | Direction::HorizontalReverse => { + Direction::Horizontal => { (coords.x as f32 - handle.min_x(), container.width()) } - Direction::Vertical | Direction::VerticalReverse => { + Direction::Vertical => { (coords.y as f32 - handle.min_y(), container.height()) } }; @@ -562,8 +562,8 @@ impl Component for ResizableHandle { let handle_size = Size::px(ResizableContext::HANDLE_SIZE); let (width, height) = match direction { - Direction::Horizontal | Direction::HorizontalReverse => (handle_size, Size::fill()), - Direction::Vertical | Direction::VerticalReverse => (Size::fill(), handle_size), + Direction::Horizontal => (handle_size, Size::fill()), + Direction::Vertical => (Size::fill(), handle_size), }; let background = match *status.read() { diff --git a/crates/freya-components/src/scrollviews/use_scroll_controller.rs b/crates/freya-components/src/scrollviews/use_scroll_controller.rs index 00d970d03..04f3e8531 100644 --- a/crates/freya-components/src/scrollviews/use_scroll_controller.rs +++ b/crates/freya-components/src/scrollviews/use_scroll_controller.rs @@ -90,21 +90,21 @@ impl ScrollController { match request { ScrollRequest { position: ScrollPosition::Start, - direction: Direction::Vertical | Direction::VerticalReverse, + direction: Direction::Vertical, .. } => { self.on_scroll.write().call(ScrollEvent::Y(0)); } ScrollRequest { position: ScrollPosition::Start, - direction: Direction::Horizontal | Direction::HorizontalReverse, + direction: Direction::Horizontal, .. } => { self.on_scroll.write().call(ScrollEvent::X(0)); } ScrollRequest { position: ScrollPosition::End, - direction: Direction::Vertical | Direction::VerticalReverse, + direction: Direction::Vertical, init, .. } => { @@ -118,7 +118,7 @@ impl ScrollController { } ScrollRequest { position: ScrollPosition::End, - direction: Direction::Horizontal | Direction::HorizontalReverse, + direction: Direction::Horizontal, init, .. } => { diff --git a/crates/freya-components/src/scrollviews/virtual_scrollview.rs b/crates/freya-components/src/scrollviews/virtual_scrollview.rs index 511e23d07..d7119e8e8 100644 --- a/crates/freya-components/src/scrollviews/virtual_scrollview.rs +++ b/crates/freya-components/src/scrollviews/virtual_scrollview.rs @@ -274,11 +274,11 @@ impl Element + 'static> Component let drag_scrolling = self.drag_scrolling; let (inner_width, inner_height) = match direction { - Direction::Vertical | Direction::VerticalReverse => ( + Direction::Vertical => ( size.read().inner_sizes.width, self.item_size * self.length as f32, ), - Direction::Horizontal | Direction::HorizontalReverse => ( + Direction::Horizontal => ( self.item_size * self.length as f32, size.read().inner_sizes.height, ), @@ -500,14 +500,14 @@ impl Element + 'static> Component .collect::>(); let (offset_x, offset_y) = match direction { - Direction::Vertical | Direction::VerticalReverse => { + Direction::Vertical => { let offset_y_min = (-corrected_scrolled_y / self.item_size).floor() * self.item_size; let offset_y = -(-corrected_scrolled_y - offset_y_min); (corrected_scrolled_x, offset_y) } - Direction::Horizontal | Direction::HorizontalReverse => { + Direction::Horizontal => { let offset_x_min = (-corrected_scrolled_x / self.item_size).floor() * self.item_size; let offset_x = -(-corrected_scrolled_x - offset_x_min); diff --git a/crates/freya-core/src/elements/extensions.rs b/crates/freya-core/src/elements/extensions.rs index b5c943179..da2bcc1be 100644 --- a/crates/freya-core/src/elements/extensions.rs +++ b/crates/freya-core/src/elements/extensions.rs @@ -19,6 +19,7 @@ use torin::{ Alignment, Direction, Length, + Order, Position, VisibleSize, }, @@ -490,6 +491,24 @@ where self.get_layout().layout.content = content; self } + + /// Set the order children are stacked in along the direction axis. See [`Order`]. + fn order(mut self, order: impl Into) -> Self { + self.get_layout().layout.order = order.into(); + self + } + + /// Stack children in their natural order along the direction axis. Shorthand for [`order`](Self::order) set to [`Order::Forward`]. + fn forward_order(mut self) -> Self { + self.get_layout().layout.order = Order::forward(); + self + } + + /// Stack children in reverse order along the direction axis. Shorthand for [`order`](Self::order) set to [`Order::Backward`]. + fn backwards_order(mut self) -> Self { + self.get_layout().layout.order = Order::backward(); + self + } /// Center children on both axes. Shorthand for [`main_align`](Self::main_align) and [`cross_align`](Self::cross_align) set to [`Alignment::Center`]. fn center(mut self) -> Self { self.get_layout().layout.main_alignment = Alignment::Center; @@ -521,18 +540,6 @@ where self.get_layout().layout.direction = Direction::horizontal(); self } - - /// Stack children vertically in reverse order. Shorthand for [`direction`](Self::direction) set to [`Direction::VerticalReverse`]. - fn vertical_reverse(mut self) -> Self { - self.get_layout().layout.direction = Direction::vertical_reverse(); - self - } - - /// Stack children horizontally in reverse order. Shorthand for [`direction`](Self::direction) set to [`Direction::HorizontalReverse`]. - fn horizontal_reverse(mut self) -> Self { - self.get_layout().layout.direction = Direction::horizontal_reverse(); - self - } } /// Methods for setting an element's width and height. diff --git a/crates/freya-devtools-app/src/components/attribute.rs b/crates/freya-devtools-app/src/components/attribute.rs index 41cf62be6..ea74e45a8 100644 --- a/crates/freya-devtools-app/src/components/attribute.rs +++ b/crates/freya-devtools-app/src/components/attribute.rs @@ -45,6 +45,7 @@ pub fn attribute_element(name: &str, attribute: AttributeType<'_>) -> Element { .into(), AttributeType::Text(text) => Property::new(name, text).into(), AttributeType::Direction(direction) => Property::new(name, direction.pretty()).into(), + AttributeType::Order(order) => Property::new(name, order.pretty()).into(), AttributeType::Position(position) => Property::new(name, position.pretty()).into(), AttributeType::Content(content) => Property::new(name, content.pretty()).into(), AttributeType::Alignment(alignment) => Property::new(name, alignment.pretty()).into(), diff --git a/crates/freya-devtools/src/node_info.rs b/crates/freya-devtools/src/node_info.rs index abc4811d6..29e298a9a 100644 --- a/crates/freya-devtools/src/node_info.rs +++ b/crates/freya-devtools/src/node_info.rs @@ -23,6 +23,7 @@ use torin::{ direction::Direction, gaps::Gaps, geometry::Length, + order::Order, prelude::{ Area, AreaOf, @@ -83,6 +84,7 @@ impl NodeState { "direction", AttributeType::Direction(&self.layout.direction), ), + ("order", AttributeType::Order(&self.layout.order)), ("padding", AttributeType::Measures(self.layout.padding)), ("margin", AttributeType::Measures(self.layout.margin)), ("position", AttributeType::Position(&self.layout.position)), @@ -190,6 +192,7 @@ pub enum AttributeType<'a> { Measures(Gaps), CornerRadius(CornerRadius), Direction(&'a Direction), + Order(&'a Order), Position(&'a Position), Content(&'a Content), Alignment(&'a Alignment), diff --git a/crates/freya/src/lib.rs b/crates/freya/src/lib.rs index 703aead2b..489e29e71 100644 --- a/crates/freya/src/lib.rs +++ b/crates/freya/src/lib.rs @@ -147,6 +147,7 @@ pub mod prelude { CursorPoint, Size2D, }, + order::Order, position::Position, size::Size, visible_size::VisibleSize, diff --git a/crates/torin/src/geometry.rs b/crates/torin/src/geometry.rs index c6fe7fb1b..680e183db 100644 --- a/crates/torin/src/geometry.rs +++ b/crates/torin/src/geometry.rs @@ -221,11 +221,11 @@ fn calculate_extreme_corners(area: &Area, center: Point2D) -> (Point2D, Point2D) impl AlignAxis { pub fn new(direction: &Direction, alignment_direction: AlignmentDirection) -> Self { match direction { - Direction::Vertical | Direction::VerticalReverse => match alignment_direction { + Direction::Vertical => match alignment_direction { AlignmentDirection::Main => AlignAxis::Height, AlignmentDirection::Cross => AlignAxis::Width, }, - Direction::Horizontal | Direction::HorizontalReverse => match alignment_direction { + Direction::Horizontal => match alignment_direction { AlignmentDirection::Main => AlignAxis::Width, AlignmentDirection::Cross => AlignAxis::Height, }, diff --git a/crates/torin/src/measure.rs b/crates/torin/src/measure.rs index fa7c4e89b..80a009564 100644 --- a/crates/torin/src/measure.rs +++ b/crates/torin/src/measure.rs @@ -544,7 +544,7 @@ where parent_is_dirty: bool, ) { let mut children = self.tree_adapter.children_of(parent_node_id); - if parent_node.direction.is_reverse() { + if parent_node.order.is_reverse() { children.reverse(); } @@ -646,12 +646,12 @@ where if parent_node.content.is_flex() { match parent_node.direction { - Direction::Vertical | Direction::VerticalReverse => { + Direction::Vertical => { if let Some(ff) = child_data.height.flex_grow() { initial_phase_flex_grows.insert(*child_id, ff); } } - Direction::Horizontal | Direction::HorizontalReverse => { + Direction::Horizontal => { if let Some(ff) = child_data.width.flex_grow() { initial_phase_flex_grows.insert(*child_id, ff); } @@ -950,7 +950,7 @@ where ) { if let Some(initial_phase_size) = initial_phase_size { match direction { - Direction::Vertical | Direction::VerticalReverse => { + Direction::Vertical => { if adapted_available_area.height() - initial_phase_size.height < 0. { let advance = inner_sizes.width + wrap_spacing; available_area.origin.y = initial_available_area.origin.y; @@ -962,7 +962,7 @@ where parent_area.size.width += advance; } } - Direction::Horizontal | Direction::HorizontalReverse => { + Direction::Horizontal => { if adapted_available_area.width() - initial_phase_size.width < 0. { let advance = inner_sizes.height + wrap_spacing; available_area.origin.x = initial_available_area.origin.x; @@ -1098,7 +1098,7 @@ where }; match parent_node.direction { - Direction::Horizontal | Direction::HorizontalReverse => { + Direction::Horizontal => { // Move the available area available_area.origin.x = child_area.max_x() + spacing.get(); available_area.size.width -= child_area.size.width + spacing.get(); @@ -1127,7 +1127,7 @@ where parent_area.size.width += child_area.size.width + spacing.get(); } } - Direction::Vertical | Direction::VerticalReverse => { + Direction::Vertical => { // Move the available area available_area.origin.y = child_area.max_y() + spacing.get(); available_area.size.height -= child_area.size.height + spacing.get(); @@ -1185,11 +1185,11 @@ where let axis = AlignAxis::new(&parent_node.direction, alignment_direction); let (is_vertical_not_start, is_horizontal_not_start) = match parent_node.direction { - Direction::Vertical | Direction::VerticalReverse => ( + Direction::Vertical => ( parent_node.main_alignment.is_not_start(), parent_node.cross_alignment.is_not_start() || parent_node.content.is_fit(), ), - Direction::Horizontal | Direction::HorizontalReverse => ( + Direction::Horizontal => ( parent_node.cross_alignment.is_not_start() || parent_node.content.is_fit(), parent_node.main_alignment.is_not_start(), ), diff --git a/crates/torin/src/node.rs b/crates/torin/src/node.rs index f7b157d9f..27e1dbf93 100644 --- a/crates/torin/src/node.rs +++ b/crates/torin/src/node.rs @@ -5,6 +5,7 @@ use crate::{ direction::Direction, gaps::Gaps, geometry::Length, + order::Order, prelude::{ Content, Position, @@ -51,6 +52,9 @@ pub struct Node { /// Direction in which it's inner Nodes will be stacked pub direction: Direction, + /// Order in which it's inner Nodes will be stacked along the direction axis + pub order: Order, + /// Position config pub position: Position, @@ -104,6 +108,7 @@ impl Node { && self.padding == other.padding && self.margin == other.margin && self.direction == other.direction + && self.order == other.order && self.position == other.position && self.content == other.content && self.has_layout_references == other.has_layout_references diff --git a/crates/torin/src/values/direction.rs b/crates/torin/src/values/direction.rs index 73736b12e..d11949832 100644 --- a/crates/torin/src/values/direction.rs +++ b/crates/torin/src/values/direction.rs @@ -5,10 +5,6 @@ pub enum Direction { #[default] Vertical, Horizontal, - /// Stack children vertically, in reverse order. - VerticalReverse, - /// Stack children horizontally, in reverse order. - HorizontalReverse, } impl Direction { @@ -22,27 +18,10 @@ impl Direction { Direction::Horizontal } - /// Use a [`VerticalReverse`](Direction::VerticalReverse) direction. - pub fn vertical_reverse() -> Direction { - Direction::VerticalReverse - } - - /// Use a [`HorizontalReverse`](Direction::HorizontalReverse) direction. - pub fn horizontal_reverse() -> Direction { - Direction::HorizontalReverse - } - - /// Whether children are stacked in reverse order. - pub fn is_reverse(&self) -> bool { - matches!(self, Self::VerticalReverse | Self::HorizontalReverse) - } - pub fn pretty(&self) -> String { match self { Self::Horizontal => "horizontal".to_string(), Self::Vertical => "vertical".to_string(), - Self::HorizontalReverse => "horizontal-reverse".to_string(), - Self::VerticalReverse => "vertical-reverse".to_string(), } } } diff --git a/crates/torin/src/values/mod.rs b/crates/torin/src/values/mod.rs index 07288819a..473ce8392 100644 --- a/crates/torin/src/values/mod.rs +++ b/crates/torin/src/values/mod.rs @@ -2,6 +2,7 @@ pub mod alignment; pub mod content; pub mod direction; pub mod gaps; +pub mod order; pub mod position; pub mod size; pub mod visible_size; @@ -12,6 +13,7 @@ pub mod prelude { content::*, direction::*, gaps::*, + order::*, position::*, size::*, visible_size::*, diff --git a/crates/torin/src/values/order.rs b/crates/torin/src/values/order.rs new file mode 100644 index 000000000..556dffb5b --- /dev/null +++ b/crates/torin/src/values/order.rs @@ -0,0 +1,33 @@ +#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))] +#[derive(PartialEq, Eq, Clone, Debug, Default, Copy)] +pub enum Order { + /// Lay children out in their natural order. This is the default. + #[default] + Forward, + /// Lay children out in reverse order along the direction axis. + Backward, +} + +impl Order { + /// Use a [`Forward`](Order::Forward) order. + pub fn forward() -> Order { + Order::Forward + } + + /// Use a [`Backward`](Order::Backward) order. + pub fn backward() -> Order { + Order::Backward + } + + /// Whether children are laid out in reverse order. + pub fn is_reverse(&self) -> bool { + matches!(self, Self::Backward) + } + + pub fn pretty(&self) -> String { + match self { + Self::Forward => "forward".to_string(), + Self::Backward => "backward".to_string(), + } + } +} diff --git a/crates/torin/tests/direction.rs b/crates/torin/tests/order.rs similarity index 79% rename from crates/torin/tests/direction.rs rename to crates/torin/tests/order.rs index 2521f49e2..eef2da67a 100644 --- a/crates/torin/tests/direction.rs +++ b/crates/torin/tests/order.rs @@ -3,6 +3,11 @@ use torin::{ test_utils::*, }; +fn backward(mut node: Node) -> Node { + node.order = Order::Backward; + node +} + fn stacked_tree(parent: Node) -> (Torin, Option, TestingTree) { let (layout, measurer) = test_utils(); @@ -33,12 +38,13 @@ fn leaf(width: f32) -> Node { } #[test] -pub fn horizontal_reverse_stacks_children_in_reverse_order() { - let (mut layout, mut measurer, mut mocked_tree) = stacked_tree(Node::from_size_and_direction( - Size::Pixels(Length::new(300.0)), - Size::Pixels(Length::new(100.0)), - Direction::HorizontalReverse, - )); +pub fn backward_order_stacks_horizontal_children_in_reverse() { + let (mut layout, mut measurer, mut mocked_tree) = + stacked_tree(backward(Node::from_size_and_direction( + Size::Pixels(Length::new(300.0)), + Size::Pixels(Length::new(100.0)), + Direction::Horizontal, + ))); layout.measure( 0, @@ -47,7 +53,6 @@ pub fn horizontal_reverse_stacks_children_in_reverse_order() { &mut mocked_tree, ); - // The last child is placed first, so the first child ends up at the far end. assert_eq!(layout.get(&3).unwrap().area.origin, Point2D::new(0.0, 0.0)); assert_eq!( layout.get(&2).unwrap().area.origin, @@ -60,12 +65,13 @@ pub fn horizontal_reverse_stacks_children_in_reverse_order() { } #[test] -pub fn vertical_reverse_stacks_children_in_reverse_order() { - let (mut layout, mut measurer, mut mocked_tree) = stacked_tree(Node::from_size_and_direction( - Size::Pixels(Length::new(100.0)), - Size::Pixels(Length::new(300.0)), - Direction::VerticalReverse, - )); +pub fn backward_order_stacks_vertical_children_in_reverse() { + let (mut layout, mut measurer, mut mocked_tree) = + stacked_tree(backward(Node::from_size_and_direction( + Size::Pixels(Length::new(100.0)), + Size::Pixels(Length::new(300.0)), + Direction::Vertical, + ))); layout.measure( 0, @@ -86,7 +92,7 @@ pub fn vertical_reverse_stacks_children_in_reverse_order() { } #[test] -pub fn reverse_composes_with_center_alignment() { +pub fn backward_order_composes_with_center_alignment() { let (mut layout, mut measurer) = test_utils(); let mut mocked_tree = TestingTree::default(); @@ -94,13 +100,13 @@ pub fn reverse_composes_with_center_alignment() { 0, None, vec![1, 2], - Node::from_size_and_alignments_and_direction( + backward(Node::from_size_and_alignments_and_direction( Size::Pixels(Length::new(300.0)), Size::Pixels(Length::new(100.0)), Alignment::Center, Alignment::Start, - Direction::HorizontalReverse, - ), + Direction::Horizontal, + )), ); for id in 1..=2 { mocked_tree.add( @@ -122,7 +128,6 @@ pub fn reverse_composes_with_center_alignment() { &mut mocked_tree, ); - // The 100px wide block is centered (origin x = 100), with the children reversed inside it. assert_eq!( layout.get(&2).unwrap().area.origin, Point2D::new(100.0, 0.0) @@ -134,16 +139,17 @@ pub fn reverse_composes_with_center_alignment() { } #[test] -pub fn reverse_keeps_spacing_between_children() { - let (mut layout, mut measurer, mut mocked_tree) = - stacked_tree(Node::from_size_and_alignments_and_direction_and_spacing( +pub fn backward_order_keeps_spacing_between_children() { + let (mut layout, mut measurer, mut mocked_tree) = stacked_tree(backward( + Node::from_size_and_alignments_and_direction_and_spacing( Size::Pixels(Length::new(320.0)), Size::Pixels(Length::new(100.0)), Alignment::Start, Alignment::Start, - Direction::HorizontalReverse, + Direction::Horizontal, Length::new(10.0), - )); + ), + )); layout.measure( 0, @@ -164,7 +170,7 @@ pub fn reverse_keeps_spacing_between_children() { } #[test] -pub fn reverse_composes_with_flex() { +pub fn backward_order_composes_with_flex() { let (mut layout, mut measurer) = test_utils(); let mut mocked_tree = TestingTree::default(); @@ -173,7 +179,8 @@ pub fn reverse_composes_with_flex() { Size::Pixels(Length::new(100.0)), Content::Flex, ); - root.direction = Direction::HorizontalReverse; + root.direction = Direction::Horizontal; + root.order = Order::Backward; mocked_tree.add(0, None, vec![1, 2, 3], root); mocked_tree.add(1, Some(0), vec![], leaf(50.0)); mocked_tree.add( @@ -195,7 +202,6 @@ pub fn reverse_composes_with_flex() { &mut mocked_tree, ); - // The flex child still grows to the leftover 200px; only the order is reversed. assert_eq!(layout.get(&3).unwrap().area.origin, Point2D::new(0.0, 0.0)); assert_eq!(layout.get(&2).unwrap().area.width(), 200.0); assert_eq!(layout.get(&2).unwrap().area.origin, Point2D::new(50.0, 0.0)); diff --git a/examples/layout_reverse_direction.rs b/examples/layout_reverse_direction.rs new file mode 100644 index 000000000..12eece455 --- /dev/null +++ b/examples/layout_reverse_direction.rs @@ -0,0 +1,58 @@ +#![cfg_attr( + all(not(debug_assertions), target_os = "windows"), + windows_subsystem = "windows" +)] +use freya::prelude::*; + +fn main() { + launch(LaunchConfig::new().with_window(WindowConfig::new(app))) +} + +fn cards() -> [Element; 3] { + [1, 2, 3].map(|index| { + Button::new() + .on_press(move |_| println!("Pressed item {index}")) + .child(format!("Item {index}")) + .into_element() + }) +} + +fn row(title: &str, content: Element) -> Element { + rect() + .width(Size::fill()) + .spacing(5.) + .child(title.to_string()) + .child(content) + .into() +} + +fn app() -> impl IntoElement { + ScrollView::new() + .spacing(20.) + .child(row( + "horizontal", + rect().horizontal().spacing(5.).children(cards()).into(), + )) + .child(row( + "horizontal + reversed", + rect() + .horizontal() + .backwards_order() + .spacing(5.) + .children(cards()) + .into(), + )) + .child(row( + "vertical", + rect().vertical().spacing(5.).children(cards()).into(), + )) + .child(row( + "vertical + reversed", + rect() + .vertical() + .backwards_order() + .spacing(5.) + .children(cards()) + .into(), + )) +} From 95009b0de27cf60fe539afbb12ffa73128b19a65 Mon Sep 17 00:00:00 2001 From: Marc Espin Date: Wed, 24 Jun 2026 16:52:33 +0200 Subject: [PATCH 3/3] remove s --- crates/freya-core/src/elements/extensions.rs | 2 +- crates/torin/src/measure.rs | 2 +- crates/torin/src/node.rs | 16 ++++ crates/torin/src/values/order.rs | 2 +- crates/torin/tests/order.rs | 88 +++++++++++--------- examples/layout_reverse_direction.rs | 4 +- 6 files changed, 68 insertions(+), 46 deletions(-) diff --git a/crates/freya-core/src/elements/extensions.rs b/crates/freya-core/src/elements/extensions.rs index da2bcc1be..35c6f1e7a 100644 --- a/crates/freya-core/src/elements/extensions.rs +++ b/crates/freya-core/src/elements/extensions.rs @@ -505,7 +505,7 @@ where } /// Stack children in reverse order along the direction axis. Shorthand for [`order`](Self::order) set to [`Order::Backward`]. - fn backwards_order(mut self) -> Self { + fn backward_order(mut self) -> Self { self.get_layout().layout.order = Order::backward(); self } diff --git a/crates/torin/src/measure.rs b/crates/torin/src/measure.rs index 80a009564..0631268a7 100644 --- a/crates/torin/src/measure.rs +++ b/crates/torin/src/measure.rs @@ -544,7 +544,7 @@ where parent_is_dirty: bool, ) { let mut children = self.tree_adapter.children_of(parent_node_id); - if parent_node.order.is_reverse() { + if parent_node.order.is_backward() { children.reverse(); } diff --git a/crates/torin/src/node.rs b/crates/torin/src/node.rs index 27e1dbf93..bbed74e0f 100644 --- a/crates/torin/src/node.rs +++ b/crates/torin/src/node.rs @@ -131,6 +131,22 @@ impl Node { } } + /// Construct a new Node given a size, a direction and an order + pub fn from_size_and_direction_and_order( + width: Size, + height: Size, + direction: Direction, + order: Order, + ) -> Self { + Self { + width, + height, + direction, + order, + ..Default::default() + } + } + /// Construct a new Node given some sizes pub fn from_sizes( width: Size, diff --git a/crates/torin/src/values/order.rs b/crates/torin/src/values/order.rs index 556dffb5b..52c46f573 100644 --- a/crates/torin/src/values/order.rs +++ b/crates/torin/src/values/order.rs @@ -20,7 +20,7 @@ impl Order { } /// Whether children are laid out in reverse order. - pub fn is_reverse(&self) -> bool { + pub fn is_backward(&self) -> bool { matches!(self, Self::Backward) } diff --git a/crates/torin/tests/order.rs b/crates/torin/tests/order.rs index eef2da67a..48a1602af 100644 --- a/crates/torin/tests/order.rs +++ b/crates/torin/tests/order.rs @@ -3,11 +3,6 @@ use torin::{ test_utils::*, }; -fn backward(mut node: Node) -> Node { - node.order = Order::Backward; - node -} - fn stacked_tree(parent: Node) -> (Torin, Option, TestingTree) { let (layout, measurer) = test_utils(); @@ -29,22 +24,15 @@ fn stacked_tree(parent: Node) -> (Torin, Option, TestingTre (layout, measurer, mocked_tree) } -fn leaf(width: f32) -> Node { - Node::from_size_and_direction( - Size::Pixels(Length::new(width)), - Size::Pixels(Length::new(100.0)), - Direction::Vertical, - ) -} - #[test] pub fn backward_order_stacks_horizontal_children_in_reverse() { let (mut layout, mut measurer, mut mocked_tree) = - stacked_tree(backward(Node::from_size_and_direction( + stacked_tree(Node::from_size_and_direction_and_order( Size::Pixels(Length::new(300.0)), Size::Pixels(Length::new(100.0)), Direction::Horizontal, - ))); + Order::Backward, + )); layout.measure( 0, @@ -67,11 +55,12 @@ pub fn backward_order_stacks_horizontal_children_in_reverse() { #[test] pub fn backward_order_stacks_vertical_children_in_reverse() { let (mut layout, mut measurer, mut mocked_tree) = - stacked_tree(backward(Node::from_size_and_direction( + stacked_tree(Node::from_size_and_direction_and_order( Size::Pixels(Length::new(100.0)), Size::Pixels(Length::new(300.0)), Direction::Vertical, - ))); + Order::Backward, + )); layout.measure( 0, @@ -95,19 +84,17 @@ pub fn backward_order_stacks_vertical_children_in_reverse() { pub fn backward_order_composes_with_center_alignment() { let (mut layout, mut measurer) = test_utils(); - let mut mocked_tree = TestingTree::default(); - mocked_tree.add( - 0, - None, - vec![1, 2], - backward(Node::from_size_and_alignments_and_direction( - Size::Pixels(Length::new(300.0)), - Size::Pixels(Length::new(100.0)), - Alignment::Center, - Alignment::Start, - Direction::Horizontal, - )), + let mut parent = Node::from_size_and_alignments_and_direction( + Size::Pixels(Length::new(300.0)), + Size::Pixels(Length::new(100.0)), + Alignment::Center, + Alignment::Start, + Direction::Horizontal, ); + parent.order = Order::Backward; + + let mut mocked_tree = TestingTree::default(); + mocked_tree.add(0, None, vec![1, 2], parent); for id in 1..=2 { mocked_tree.add( id, @@ -140,16 +127,17 @@ pub fn backward_order_composes_with_center_alignment() { #[test] pub fn backward_order_keeps_spacing_between_children() { - let (mut layout, mut measurer, mut mocked_tree) = stacked_tree(backward( - Node::from_size_and_alignments_and_direction_and_spacing( - Size::Pixels(Length::new(320.0)), - Size::Pixels(Length::new(100.0)), - Alignment::Start, - Alignment::Start, - Direction::Horizontal, - Length::new(10.0), - ), - )); + let mut parent = Node::from_size_and_alignments_and_direction_and_spacing( + Size::Pixels(Length::new(320.0)), + Size::Pixels(Length::new(100.0)), + Alignment::Start, + Alignment::Start, + Direction::Horizontal, + Length::new(10.0), + ); + parent.order = Order::Backward; + + let (mut layout, mut measurer, mut mocked_tree) = stacked_tree(parent); layout.measure( 0, @@ -182,7 +170,16 @@ pub fn backward_order_composes_with_flex() { root.direction = Direction::Horizontal; root.order = Order::Backward; mocked_tree.add(0, None, vec![1, 2, 3], root); - mocked_tree.add(1, Some(0), vec![], leaf(50.0)); + mocked_tree.add( + 1, + Some(0), + vec![], + Node::from_size_and_direction( + Size::Pixels(Length::new(50.0)), + Size::Pixels(Length::new(100.0)), + Direction::Vertical, + ), + ); mocked_tree.add( 2, Some(0), @@ -193,7 +190,16 @@ pub fn backward_order_composes_with_flex() { Direction::Vertical, ), ); - mocked_tree.add(3, Some(0), vec![], leaf(50.0)); + mocked_tree.add( + 3, + Some(0), + vec![], + Node::from_size_and_direction( + Size::Pixels(Length::new(50.0)), + Size::Pixels(Length::new(100.0)), + Direction::Vertical, + ), + ); layout.measure( 0, diff --git a/examples/layout_reverse_direction.rs b/examples/layout_reverse_direction.rs index 12eece455..a7a35d366 100644 --- a/examples/layout_reverse_direction.rs +++ b/examples/layout_reverse_direction.rs @@ -37,7 +37,7 @@ fn app() -> impl IntoElement { "horizontal + reversed", rect() .horizontal() - .backwards_order() + .backward_order() .spacing(5.) .children(cards()) .into(), @@ -50,7 +50,7 @@ fn app() -> impl IntoElement { "vertical + reversed", rect() .vertical() - .backwards_order() + .backward_order() .spacing(5.) .children(cards()) .into(),