me/iced
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

Make Shrink have priority over Fill in layout

Browse source
This commit is contained in:
Héctor Ramón Jiménez 2023-03-16 20:23:25 +01:00 • committed by Héctor Ramón Jiménez
parent 68c0484b5c
commit 0655a20ad1
No known key found for this signature in database
GPG key ID: 7CC46565708259A7
46 changed files with 264 additions and 273 deletions
Download patch file Download diff file Expand all files Collapse all files

13
widget/src/button.rs
View file

@ -433,13 +433,18 @@ pub fn layout(
) -> layout::Node {
let limits = limits.width(width).height(height);
let mut content = layout_content(&limits.pad(padding));
let content = layout_content(&limits.shrink(padding));
let padding = padding.fit(content.size(), limits.max());
let size = limits.pad(padding).resolve(content.size()).pad(padding);
content.move_to(Point::new(padding.left, padding.top));
let size = limits
.shrink(padding)
.resolve(content.size(), width, height)
.expand(padding);
layout::Node::with_children(size, vec![content])
layout::Node::with_children(
size,
vec![content.move_to(Point::new(padding.left, padding.top))],
)
}
/// Returns the [`mouse::Interaction`] of a [`Button`].

3
widget/src/canvas.rs
View file

@ -133,8 +133,7 @@ where
_renderer: &Renderer,
limits: &layout::Limits,
) -> layout::Node {
let limits = limits.width(self.width).height(self.height);
let size = limits.resolve(Size::ZERO);
let size = limits.resolve(Size::ZERO, self.width, self.height);
layout::Node::new(size)
}

9
widget/src/column.rs
View file

@ -35,7 +35,7 @@ impl<'a, Message, Renderer> Column<'a, Message, Renderer> {
Column {
spacing: 0.0,
padding: Padding::ZERO,
width: Length::Shrink,
width: Length::Fill,
height: Length::Shrink,
max_width: f32::INFINITY,
align_items: Alignment::Start,
@ -126,15 +126,14 @@ where
renderer: &Renderer,
limits: &layout::Limits,
) -> layout::Node {
let limits = limits
.max_width(self.max_width)
.width(self.width)
.height(self.height);
let limits = limits.max_width(self.max_width);
layout::flex::resolve(
layout::flex::Axis::Vertical,
renderer,
&limits,
self.width,
self.height,
self.padding,
self.spacing,
self.align_items,

31
widget/src/container.rs
View file

@ -312,24 +312,27 @@ pub fn layout(
layout_content: impl FnOnce(&layout::Limits) -> layout::Node,
) -> layout::Node {
let limits = limits
.loose()
.max_width(max_width)
.max_height(max_height)
.width(width)
.height(height);
.height(height)
.max_width(max_width)
.max_height(max_height);
let mut content = layout_content(&limits.pad(padding).loose());
let content = layout_content(&limits.shrink(padding).loose());
let padding = padding.fit(content.size(), limits.max());
let size = limits.pad(padding).resolve(content.size());
let size = limits
.shrink(padding)
.resolve(content.size(), width, height);
content.move_to(Point::new(padding.left, padding.top));
content.align(
Alignment::from(horizontal_alignment),
Alignment::from(vertical_alignment),
size,
);
layout::Node::with_children(size.pad(padding), vec![content])
layout::Node::with_children(
size.expand(padding),
vec![content
.move_to(Point::new(padding.left, padding.top))
.align(
Alignment::from(horizontal_alignment),
Alignment::from(vertical_alignment),
size,
)],
)
}
/// Draws the background of a [`Container`] given its [`Appearance`] and its `bounds`.

2
widget/src/image.rs
View file

@ -99,7 +99,7 @@ where
};
// The size to be available to the widget prior to `Shrink`ing
let raw_size = limits.width(width).height(height).resolve(image_size);
let raw_size = limits.resolve(image_size, width, height);
// The uncropped size of the image when fit to the bounds above
let full_size = content_fit.fit(image_size, raw_size);

9
widget/src/image/viewer.rs
View file

@ -113,10 +113,11 @@ where
) -> layout::Node {
let Size { width, height } = renderer.dimensions(&self.handle);
let mut size = limits
.width(self.width)
.height(self.height)
.resolve(Size::new(width as f32, height as f32));
let mut size = limits.resolve(
Size::new(width as f32, height as f32),
self.width,
self.height,
);
let expansion_size = if height > width {
self.width

2
widget/src/keyed/column.rs
View file

@ -196,6 +196,8 @@ where
layout::flex::Axis::Vertical,
renderer,
&limits,
self.width,
self.height,
self.padding,
self.spacing,
self.align_items,

12
widget/src/overlay/menu.rs
View file

@ -254,15 +254,14 @@ where
)
.width(self.width);
let mut node = self.container.layout(self.state, renderer, &limits);
let node = self.container.layout(self.state, renderer, &limits);
let size = node.size();
node.move_to(if space_below > space_above {
position + Vector::new(0.0, self.target_height)
} else {
position - Vector::new(0.0, node.size().height)
});
node
position - Vector::new(0.0, size.height)
})
}
fn on_event(
@ -359,7 +358,6 @@ where
) -> layout::Node {
use std::f32;
let limits = limits.width(Length::Fill).height(Length::Shrink);
let text_size =
self.text_size.unwrap_or_else(|| renderer.default_size());
@ -372,7 +370,7 @@ where
* self.options.len() as f32,
);
limits.resolve(intrinsic)
limits.resolve(intrinsic, Length::Fill, Length::Shrink)
};
layout::Node::new(size)

9
widget/src/pane_grid.rs
View file

@ -490,8 +490,7 @@ pub fn layout<Renderer, T>(
&layout::Limits,
) -> layout::Node,
) -> layout::Node {
let limits = limits.width(width).height(height);
let size = limits.resolve(Size::ZERO);
let size = limits.resolve(Size::ZERO, width, height);
let regions = node.pane_regions(spacing, size);
let children = contents
@ -500,16 +499,14 @@ pub fn layout<Renderer, T>(
let region = regions.get(&pane)?;
let size = Size::new(region.width, region.height);
let mut node = layout_content(
let node = layout_content(
content,
tree,
renderer,
&layout::Limits::new(size, size),
);
node.move_to(Point::new(region.x, region.y));
Some(node)
Some(node.move_to(Point::new(region.x, region.y)))
})
.collect();

9
widget/src/pane_grid/content.rs
View file

@ -165,7 +165,7 @@ where
let title_bar_size = title_bar_layout.size();
let mut body_layout = self.body.as_widget().layout(
let body_layout = self.body.as_widget().layout(
&mut tree.children[0],
renderer,
&layout::Limits::new(
@ -177,11 +177,12 @@ where
),
);
body_layout.move_to(Point::new(0.0, title_bar_size.height));
layout::Node::with_children(
max_size,
vec![title_bar_layout, body_layout],
vec![
title_bar_layout,
body_layout.move_to(Point::new(0.0, title_bar_size.height)),
],
)
} else {
self.body.as_widget().layout(

18
widget/src/pane_grid/title_bar.rs
View file

@ -217,7 +217,7 @@ where
renderer: &Renderer,
limits: &layout::Limits,
) -> layout::Node {
let limits = limits.pad(self.padding);
let limits = limits.shrink(self.padding);
let max_size = limits.max();
let title_layout = self.content.as_widget().layout(
@ -228,8 +228,8 @@ where
let title_size = title_layout.size();
let mut node = if let Some(controls) = &self.controls {
let mut controls_layout = controls.as_widget().layout(
let node = if let Some(controls) = &self.controls {
let controls_layout = controls.as_widget().layout(
&mut tree.children[1],
renderer,
&layout::Limits::new(Size::ZERO, max_size),
@ -240,11 +240,13 @@ where
let height = title_size.height.max(controls_size.height);
controls_layout.move_to(Point::new(space_before_controls, 0.0));
layout::Node::with_children(
Size::new(max_size.width, height),
vec![title_layout, controls_layout],
vec![
title_layout,
controls_layout
.move_to(Point::new(space_before_controls, 0.0)),
],
)
} else {
layout::Node::with_children(
@ -253,9 +255,7 @@ where
)
};
node.move_to(Point::new(self.padding.left, self.padding.top));
layout::Node::with_children(node.size().pad(self.padding), vec![node])
layout::Node::container(node, self.padding)
}
pub(crate) fn operate(

7
widget/src/pick_list.rs
View file

@ -393,7 +393,7 @@ where
{
use std::f32;
let limits = limits.width(width).height(Length::Shrink).pad(padding);
let limits = limits.width(width).height(Length::Shrink);
let font = font.unwrap_or_else(|| renderer.default_font());
let text_size = text_size.unwrap_or_else(|| renderer.default_size());
@ -451,7 +451,10 @@ where
f32::from(text_line_height.to_absolute(text_size)),
);
limits.resolve(intrinsic).pad(padding)
limits
.shrink(padding)
.resolve(intrinsic, width, Length::Shrink)
.expand(padding)
};
layout::Node::new(size)

10
widget/src/progress_bar.rs
View file

@ -99,11 +99,11 @@ where
_renderer: &Renderer,
limits: &layout::Limits,
) -> layout::Node {
let limits = limits
.width(self.width)
.height(self.height.unwrap_or(Length::Fixed(Self::DEFAULT_HEIGHT)));
let size = limits.resolve(Size::ZERO);
let size = limits.resolve(
Size::ZERO,
self.width,
self.height.unwrap_or(Length::Fixed(Self::DEFAULT_HEIGHT)),
);
layout::Node::new(size)
}

6
widget/src/row.rs
View file

@ -34,7 +34,7 @@ impl<'a, Message, Renderer> Row<'a, Message, Renderer> {
Row {
spacing: 0.0,
padding: Padding::ZERO,
width: Length::Shrink,
width: Length::Fill,
height: Length::Shrink,
align_items: Alignment::Start,
children,
@ -118,12 +118,12 @@ where
renderer: &Renderer,
limits: &layout::Limits,
) -> layout::Node {
let limits = limits.width(self.width).height(self.height);
layout::flex::resolve(
layout::flex::Axis::Horizontal,
renderer,
&limits,
self.width,
self.height,
self.padding,
self.spacing,
self.align_items,

4
widget/src/rule.rs
View file

@ -76,9 +76,7 @@ where
_renderer: &Renderer,
limits: &layout::Limits,
) -> layout::Node {
let limits = limits.width(self.width).height(self.height);
layout::Node::new(limits.resolve(Size::ZERO))
layout::Node::new(limits.resolve(Size::ZERO, self.width, self.height))
}
fn draw(

2
widget/src/scrollable.rs
View file

@ -489,7 +489,7 @@ pub fn layout<Renderer>(
);
let content = layout_content(renderer, &child_limits);
let size = limits.resolve(content.size());
let size = limits.resolve(content.size(), width, height);
layout::Node::with_children(size, vec![content])
}

2
widget/src/shader.rs
View file

@ -85,7 +85,7 @@ where
limits: &layout::Limits,
) -> layout::Node {
let limits = limits.width(self.width).height(self.height);
let size = limits.resolve(Size::ZERO);
let size = limits.resolve(Size::ZERO, self.width, self.height);
layout::Node::new(size)
}

3
widget/src/slider.rs
View file

@ -173,8 +173,7 @@ where
_renderer: &Renderer,
limits: &layout::Limits,
) -> layout::Node {
let limits = limits.width(self.width).height(self.height);
let size = limits.resolve(Size::ZERO);
let size = limits.resolve(Size::ZERO, self.width, self.height);
layout::Node::new(size)
}

4
widget/src/space.rs
View file

@ -59,9 +59,7 @@ where
_renderer: &Renderer,
limits: &layout::Limits,
) -> layout::Node {
let limits = limits.width(self.width).height(self.height);
layout::Node::new(limits.resolve(Size::ZERO))
layout::Node::new(limits.resolve(Size::ZERO, self.width, self.height))
}
fn draw(

5
widget/src/svg.rs
View file

@ -115,10 +115,7 @@ where
let image_size = Size::new(width as f32, height as f32);
// The size to be available to the widget prior to `Shrink`ing
let raw_size = limits
.width(self.width)
.height(self.height)
.resolve(image_size);
let raw_size = limits.resolve(image_size, self.width, self.height);
// The uncropped size of the image when fit to the bounds above
let full_size = self.content_fit.fit(image_size, raw_size);

2
widget/src/text_editor.rs
View file

@ -350,7 +350,7 @@ where
}
internal.editor.update(
limits.pad(self.padding).max(),
limits.shrink(self.padding).max(),
self.font.unwrap_or_else(|| renderer.default_font()),
self.text_size.unwrap_or_else(|| renderer.default_size()),
self.line_height,

57
widget/src/text_input.rs
View file

@ -506,14 +506,11 @@ where
{
let font = font.unwrap_or_else(|| renderer.default_font());
let text_size = size.unwrap_or_else(|| renderer.default_size());
let padding = padding.fit(Size::ZERO, limits.max());
let limits = limits
.width(width)
.pad(padding)
.height(line_height.to_absolute(text_size));
let height = line_height.to_absolute(text_size);
let text_bounds = limits.resolve(Size::ZERO);
let limits = limits.width(width).shrink(padding).height(height);
let text_bounds = limits.resolve(Size::ZERO, width, height);
let placeholder_text = Text {
font,
@ -552,41 +549,41 @@ where
let icon_width = state.icon.min_width();
let mut text_node = layout::Node::new(
text_bounds - Size::new(icon_width + icon.spacing, 0.0),
);
let mut icon_node =
layout::Node::new(Size::new(icon_width, text_bounds.height));
match icon.side {
Side::Left => {
text_node.move_to(Point::new(
let (text_position, icon_position) = match icon.side {
Side::Left => (
Point::new(
padding.left + icon_width + icon.spacing,
padding.top,
));
icon_node.move_to(Point::new(padding.left, padding.top));
}
Side::Right => {
text_node.move_to(Point::new(padding.left, padding.top));
icon_node.move_to(Point::new(
),
Point::new(padding.left, padding.top),
),
Side::Right => (
Point::new(padding.left, padding.top),
Point::new(
padding.left + text_bounds.width - icon_width,
padding.top,
));
}
),
),
};
let text_node = layout::Node::new(
text_bounds - Size::new(icon_width + icon.spacing, 0.0),
)
.move_to(text_position);
let icon_node =
layout::Node::new(Size::new(icon_width, text_bounds.height))
.move_to(icon_position);
layout::Node::with_children(
text_bounds.pad(padding),
text_bounds.expand(padding),
vec![text_node, icon_node],
)
} else {
let mut text = layout::Node::new(text_bounds);
text.move_to(Point::new(padding.left, padding.top));
let text = layout::Node::new(text_bounds)
.move_to(Point::new(padding.left, padding.top));
layout::Node::with_children(text_bounds.pad(padding), vec![text])
layout::Node::with_children(text_bounds.expand(padding), vec![text])
}
}

2
widget/src/tooltip.rs
View file

@ -353,7 +353,7 @@ where
.then(|| viewport.size())
.unwrap_or(Size::INFINITY),
)
.pad(Padding::new(self.padding)),
.shrink(Padding::new(self.padding)),
);
let text_bounds = text_layout.bounds();

3
widget/src/vertical_slider.rs
View file

@ -170,8 +170,7 @@ where
_renderer: &Renderer,
limits: &layout::Limits,
) -> layout::Node {
let limits = limits.width(self.width).height(self.height);
let size = limits.resolve(Size::ZERO);
let size = limits.resolve(Size::ZERO, self.width, self.height);
layout::Node::new(size)
}