leyoda/iced-yoda
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions 1

Merge pull request #3045 from iced-rs/limits-compression

Browse source 
Prioritize `Shrink` over `Fill`
This commit is contained in:
Héctor 2025-08-29 03:55:30 +02:00 • committed by GitHub
commit caeb9ce49c
No known key found for this signature in database
GPG key ID: B5690EEEBB952194
4 changed files with 106 additions and 89 deletions
Download patch file Download diff file Expand all files Collapse all files

120
core/src/layout/flex.rs
View file

@ -78,13 +78,13 @@ where
let total_spacing = spacing * items.len().saturating_sub(1) as f32; let total_spacing = spacing * items.len().saturating_sub(1) as f32;
let max_cross = axis.cross(limits.max()); let max_cross = axis.cross(limits.max());
let compression = limits.compression();
let (main_compress, cross_compress) =
axis.pack(compression.width, compression.height);
let mut fill_main_sum = 0; let mut fill_main_sum = 0;
let mut some_fill_cross = false; let mut some_fill_cross = false;
let (mut cross, cross_compress) = match axis { let mut cross = if cross_compress { 0.0 } else { max_cross };
Axis::Vertical if width == Length::Shrink => (0.0, true),
Axis::Horizontal if height == Length::Shrink => (0.0, true),
_ => (max_cross, false),
};
let mut available = axis.main(limits.max()) - total_spacing; let mut available = axis.main(limits.max()) - total_spacing;
@ -103,7 +103,8 @@ where
axis.pack(size.width.fill_factor(), size.height.fill_factor()) axis.pack(size.width.fill_factor(), size.height.fill_factor())
}; };
if fill_main_factor == 0 && (!cross_compress || fill_cross_factor == 0) if (main_compress || fill_main_factor == 0)
&& (!cross_compress || fill_cross_factor == 0)
{ {
let (max_width, max_height) = axis.pack( let (max_width, max_height) = axis.pack(
available, available,
@ -114,8 +115,11 @@ where
}, },
); );
let child_limits = let child_limits = Limits::with_compression(
Limits::new(Size::ZERO, Size::new(max_width, max_height)); Size::ZERO,
Size::new(max_width, max_height),
compression,
);
let layout = let layout =
child.as_widget_mut().layout(tree, renderer, &child_limits); child.as_widget_mut().layout(tree, renderer, &child_limits);
@ -151,7 +155,9 @@ where
axis.pack(size.width, size.height) axis.pack(size.width, size.height)
}; };
if main_size.fill_factor() == 0 && cross_size.fill_factor() != 0 { if (main_compress || main_size.fill_factor() == 0)
&& cross_size.fill_factor() != 0
{
if let Length::Fixed(main) = main_size { if let Length::Fixed(main) = main_size {
available -= main; available -= main;
continue; continue;
@ -159,8 +165,11 @@ where
let (max_width, max_height) = axis.pack(available, cross); let (max_width, max_height) = axis.pack(available, cross);
let child_limits = let child_limits = Limits::with_compression(
Limits::new(Size::ZERO, Size::new(max_width, max_height)); Size::ZERO,
Size::new(max_width, max_height),
compression,
);
let layout = let layout =
child.as_widget_mut().layout(tree, renderer, &child_limits); child.as_widget_mut().layout(tree, renderer, &child_limits);
@ -174,64 +183,59 @@ where
} }
} }
let remaining = match axis { let remaining = available.max(0.0);
Axis::Horizontal => match width {
Length::Shrink => 0.0,
_ => available.max(0.0),
},
Axis::Vertical => match height {
Length::Shrink => 0.0,
_ => available.max(0.0),
},
};
// THIRD PASS // THIRD PASS (conditional)
// We lay out the elements that are fluid in the main axis. // We lay out the elements that are fluid in the main axis.
// We use the remaining space to evenly allocate space based on fill factors. // We use the remaining space to evenly allocate space based on fill factors.
for (i, (child, tree)) in items.iter_mut().zip(trees.iter_mut()).enumerate() if !main_compress {
{ for (i, (child, tree)) in
let (fill_main_factor, fill_cross_factor) = { items.iter_mut().zip(trees.iter_mut()).enumerate()
let size = child.as_widget().size(); {
let (fill_main_factor, fill_cross_factor) = {
let size = child.as_widget().size();
axis.pack(size.width.fill_factor(), size.height.fill_factor()) axis.pack(size.width.fill_factor(), size.height.fill_factor())
};
if fill_main_factor != 0 {
let max_main =
remaining * fill_main_factor as f32 / fill_main_sum as f32;
let max_main = if max_main.is_nan() {
f32::INFINITY
} else {
max_main
}; };
let min_main = if max_main.is_infinite() { if fill_main_factor != 0 {
0.0 let max_main =
} else { remaining * fill_main_factor as f32 / fill_main_sum as f32;
max_main
};
let (min_width, min_height) = axis.pack(min_main, 0.0); let max_main = if max_main.is_nan() {
let (max_width, max_height) = axis.pack( f32::INFINITY
max_main,
if fill_cross_factor == 0 {
max_cross
} else { } else {
cross max_main
}, };
);
let child_limits = Limits::new( let min_main = if max_main.is_infinite() {
Size::new(min_width, min_height), 0.0
Size::new(max_width, max_height), } else {
); max_main
};
let layout = let (min_width, min_height) = axis.pack(min_main, 0.0);
child.as_widget_mut().layout(tree, renderer, &child_limits); let (max_width, max_height) = axis.pack(
cross = cross.max(axis.cross(layout.size())); max_main,
if fill_cross_factor == 0 {
max_cross
} else {
cross
},
);
nodes[i] = layout; let child_limits = Limits::with_compression(
Size::new(min_width, min_height),
Size::new(max_width, max_height),
compression,
);
let layout =
child.as_widget_mut().layout(tree, renderer, &child_limits);
cross = cross.max(axis.cross(layout.size()));
nodes[i] = layout;
}
} }
} }

41
core/src/layout/limits.rs
View file

@ -6,7 +6,7 @@ use crate::{Length, Size};
pub struct Limits { pub struct Limits {
min: Size, min: Size,
max: Size, max: Size,
compress: Size<bool>, compression: Size<bool>,
} }
impl Limits { impl Limits {
@ -14,15 +14,25 @@ impl Limits {
pub const NONE: Limits = Limits { pub const NONE: Limits = Limits {
min: Size::ZERO, min: Size::ZERO,
max: Size::INFINITE, max: Size::INFINITE,
compress: Size::new(false, false), compression: Size::new(false, false),
}; };
/// Creates new [`Limits`] with the given minimum and maximum [`Size`]. /// Creates new [`Limits`] with the given minimum and maximum [`Size`].
pub const fn new(min: Size, max: Size) -> Limits { pub const fn new(min: Size, max: Size) -> Limits {
Limits::with_compression(min, max, Size::new(false, false))
}
/// Creates new [`Limits`] with the given minimun and maximum [`Size`], and
/// whether fluid lengths should be compressed to intrinsic dimensions.
pub const fn with_compression(
min: Size,
max: Size,
compress: Size<bool>,
) -> Self {
Limits { Limits {
min, min,
max, max,
compress: Size::new(false, false), compression: compress,
} }
} }
@ -36,18 +46,23 @@ impl Limits {
self.max self.max
} }
/// Returns the compression of the [`Limits`].
pub fn compression(&self) -> Size<bool> {
self.compression
}
/// Applies a width constraint to the current [`Limits`]. /// Applies a width constraint to the current [`Limits`].
pub fn width(mut self, width: impl Into<Length>) -> Limits { pub fn width(mut self, width: impl Into<Length>) -> Limits {
match width.into() { match width.into() {
Length::Shrink => { Length::Shrink => {
self.compress.width = true; self.compression.width = true;
} }
Length::Fixed(amount) => { Length::Fixed(amount) => {
let new_width = amount.min(self.max.width).max(self.min.width); let new_width = amount.min(self.max.width).max(self.min.width);
self.min.width = new_width; self.min.width = new_width;
self.max.width = new_width; self.max.width = new_width;
self.compress.width = false; self.compression.width = false;
} }
Length::Fill | Length::FillPortion(_) => {} Length::Fill | Length::FillPortion(_) => {}
} }
@ -59,7 +74,7 @@ impl Limits {
pub fn height(mut self, height: impl Into<Length>) -> Limits { pub fn height(mut self, height: impl Into<Length>) -> Limits {
match height.into() { match height.into() {
Length::Shrink => { Length::Shrink => {
self.compress.height = true; self.compression.height = true;
} }
Length::Fixed(amount) => { Length::Fixed(amount) => {
let new_height = let new_height =
@ -67,7 +82,7 @@ impl Limits {
self.min.height = new_height; self.min.height = new_height;
self.max.height = new_height; self.max.height = new_height;
self.compress.height = false; self.compression.height = false;
} }
Length::Fill | Length::FillPortion(_) => {} Length::Fill | Length::FillPortion(_) => {}
} }
@ -120,7 +135,7 @@ impl Limits {
Limits { Limits {
min, min,
max, max,
compress: self.compress, compression: self.compression,
} }
} }
@ -129,7 +144,7 @@ impl Limits {
Limits { Limits {
min: Size::ZERO, min: Size::ZERO,
max: self.max, max: self.max,
compress: self.compress, compression: self.compression,
} }
} }
@ -143,7 +158,9 @@ impl Limits {
intrinsic_size: Size, intrinsic_size: Size,
) -> Size { ) -> Size {
let width = match width.into() { let width = match width.into() {
Length::Fill | Length::FillPortion(_) if !self.compress.width => { Length::Fill | Length::FillPortion(_)
if !self.compression.width =>
{
self.max.width self.max.width
} }
Length::Fixed(amount) => { Length::Fixed(amount) => {
@ -153,7 +170,9 @@ impl Limits {
}; };
let height = match height.into() { let height = match height.into() {
Length::Fill | Length::FillPortion(_) if !self.compress.height => { Length::Fill | Length::FillPortion(_)
if !self.compression.height =>
{
self.max.height self.max.height
} }
Length::Fixed(amount) => { Length::Fixed(amount) => {

8
examples/layout/src/main.rs
View file

@ -94,14 +94,14 @@ impl Layout {
let controls = row([ let controls = row([
(!self.example.is_first()).then_some( (!self.example.is_first()).then_some(
button("← Previous") button(text("← Previous").shaping(text::Shaping::Advanced))
.padding([5, 10]) .padding([5, 10])
.on_press(Message::Previous) .on_press(Message::Previous)
.into(), .into(),
), ),
Some(horizontal_space().into()), Some(horizontal_space().into()),
(!self.example.is_last()).then_some( (!self.example.is_last()).then_some(
button("Next →") button(text("Next →").shaping(text::Shaping::Advanced))
.padding([5, 10]) .padding([5, 10])
.on_press(Message::Next) .on_press(Message::Next)
.into(), .into(),
@ -294,7 +294,7 @@ fn quotes<'a>() -> Element<'a, Message> {
fn quote<'a>( fn quote<'a>(
content: impl Into<Element<'a, Message>>, content: impl Into<Element<'a, Message>>,
) -> Element<'a, Message> { ) -> Element<'a, Message> {
row![vertical_rule(2), content.into()] row![vertical_rule(1), content.into()]
.spacing(10) .spacing(10)
.height(Shrink) .height(Shrink)
.into() .into()
@ -313,7 +313,7 @@ fn quotes<'a>() -> Element<'a, Message> {
"This is another reply", "This is another reply",
), ),
horizontal_rule(1), horizontal_rule(1),
"A separator ↑", text("A separator ↑").shaping(text::Shaping::Advanced),
] ]
.width(Shrink) .width(Shrink)
.spacing(10) .spacing(10)

26
widget/src/scrollable.rs
View file

@ -111,22 +111,12 @@ where
class: Theme::default(), class: Theme::default(),
last_status: None, last_status: None,
} }
.validate() .enclose()
} }
fn validate(mut self) -> Self { fn enclose(mut self) -> Self {
let size_hint = self.content.as_widget().size_hint(); let size_hint = self.content.as_widget().size_hint();
debug_assert!(
self.direction.vertical().is_none() || !size_hint.height.is_fill(),
"scrollable content must not fill its vertical scrolling axis"
);
debug_assert!(
self.direction.horizontal().is_none() || !size_hint.width.is_fill(),
"scrollable content must not fill its horizontal scrolling axis"
);
if self.direction.horizontal().is_none() { if self.direction.horizontal().is_none() {
self.width = self.width.enclose(size_hint.width); self.width = self.width.enclose(size_hint.width);
} }
@ -146,7 +136,7 @@ where
/// Sets the [`Direction`] of the [`Scrollable`]. /// Sets the [`Direction`] of the [`Scrollable`].
pub fn direction(mut self, direction: impl Into<Direction>) -> Self { pub fn direction(mut self, direction: impl Into<Direction>) -> Self {
self.direction = direction.into(); self.direction = direction.into();
self.validate() self.enclose()
} }
/// Sets the [`Id`] of the [`Scrollable`]. /// Sets the [`Id`] of the [`Scrollable`].
@ -437,20 +427,24 @@ where
..Padding::ZERO ..Padding::ZERO
}, },
|limits| { |limits| {
let child_limits = layout::Limits::new( let is_horizontal = self.direction.horizontal().is_some();
let is_vertical = self.direction.vertical().is_some();
let child_limits = layout::Limits::with_compression(
limits.min(), limits.min(),
Size::new( Size::new(
if self.direction.horizontal().is_some() { if is_horizontal {
f32::INFINITY f32::INFINITY
} else { } else {
limits.max().width limits.max().width
}, },
if self.direction.vertical().is_some() { if is_vertical {
f32::INFINITY f32::INFINITY
} else { } else {
limits.max().height limits.max().height
}, },
), ),
Size::new(is_horizontal, is_vertical),
); );
self.content.as_widget_mut().layout( self.content.as_widget_mut().layout(