From ca1fcdaf1454fd3febae8e6864c9a7dec04f41b1 Mon Sep 17 00:00:00 2001 From: Emi Simpson Date: Sat, 22 Jan 2022 20:09:35 -0500 Subject: Add support for `ContentFit` for `Image` --- core/src/image.rs | 119 +++++++++++++++++++++++++++++++++++++++++++++ core/src/lib.rs | 2 + examples/tour/src/main.rs | 98 +++++++++++++++++++++++++++++-------- native/src/lib.rs | 4 +- native/src/widget/image.rs | 66 +++++++++++++++++++------ src/widget.rs | 1 + 6 files changed, 252 insertions(+), 38 deletions(-) create mode 100644 core/src/image.rs diff --git a/core/src/image.rs b/core/src/image.rs new file mode 100644 index 00000000..97a9eb2c --- /dev/null +++ b/core/src/image.rs @@ -0,0 +1,119 @@ +//! Control the fit of some content (like an image) within a space + +use crate::Size; + +/// How the image should scale to fit the bounding box of the widget +/// +/// Each variant of this enum is a strategy that can be applied for resolving +/// differences in aspect ratio and size between the image being displayed and +/// the space its being displayed in. +/// +/// For an interactive demonstration of these properties as they are implemented +/// in CSS, see [Mozilla's docs][1], or run the `tour` example +/// +/// [1]: https://developer.mozilla.org/en-US/docs/Web/CSS/object-fit +#[derive(Debug, Hash, Clone, Copy, PartialEq, Eq)] +pub enum ContentFit { + /// Scale as big as it can be without needing to crop or hide parts + /// + /// The image will be scaled (preserving aspect ratio) so that it just fits + /// within the window. This won't distort the image or crop/hide any edges, + /// but if the image doesn't fit perfectly, there may be whitespace on the + /// top/bottom or left/right. + /// + /// This is a great fit for when you need to display an image without losing + /// any part of it, particularly when the image itself is the focus of the + /// screen. + Contain, + + /// Scale the image to cover all of the bounding box, cropping if needed + /// + /// This doesn't distort the image, and it ensures that the widget's area is + /// completely covered, but it might crop off a bit of the edges of the + /// widget, particularly when there is a big difference between the aspect + /// ratio of the widget and the aspect ratio of the image. + /// + /// This is best for when you're using an image as a background, or to fill + /// space, and any details of the image around the edge aren't too + /// important. + Cover, + + /// Distort the image so the widget is 100% covered without cropping + /// + /// This stretches the image to fit the widget, without any whitespace or + /// cropping. However, because of the stretch, the image may look distorted + /// or elongated, particularly when there's a mismatch of aspect ratios. + Fill, + + /// Don't resize or scale the image at all + /// + /// This will not apply any transformations to the provided image, but also + /// means that unless you do the math yourself, the widget's area will not + /// be completely covered, or the image might be cropped. + /// + /// This is best for when you've sized the image yourself. + None, + + /// Scale the image down if it's too big for the space, but never scale it up + /// + /// This works much like [`Contain`](Self::Contain), except that if the + /// image would have been scaled up, it keeps its original resolution to + /// avoid the bluring that accompanies upscaling images. + ScaleDown, +} + +impl ContentFit { + /// Attempt to apply the given fit for a content size within some bounds + /// + /// The returned value is the recommended scaled size of the content. + pub fn fit(&self, content: Size, bounds: Size) -> Size { + let content_ar = content.width / content.height; + let bounds_ar = bounds.width / bounds.height; + + match self { + Self::Contain => { + if bounds_ar > content_ar { + Size { + width: content.width * bounds.height / content.height, + ..bounds + } + } else { + Size { + height: content.height * bounds.width / content.width, + ..bounds + } + } + } + Self::Cover => { + if bounds_ar < content_ar { + Size { + width: content.width * bounds.height / content.height, + ..bounds + } + } else { + Size { + height: content.height * bounds.width / content.width, + ..bounds + } + } + } + Self::Fill => bounds, + Self::None => content, + Self::ScaleDown => { + if bounds_ar > content_ar && bounds.height < content.height { + Size { + width: content.width * bounds.height / content.height, + ..bounds + } + } else if bounds.width < content.width { + Size { + height: content.height * bounds.width / content.width, + ..bounds + } + } else { + content + } + } + } + } +} diff --git a/core/src/lib.rs b/core/src/lib.rs index 2a4e6158..0eac97c2 100644 --- a/core/src/lib.rs +++ b/core/src/lib.rs @@ -22,6 +22,7 @@ pub mod time; mod background; mod color; mod font; +mod image; mod length; mod padding; mod point; @@ -33,6 +34,7 @@ pub use alignment::Alignment; pub use background::Background; pub use color::Color; pub use font::Font; +pub use image::ContentFit; pub use length::Length; pub use padding::Padding; pub use point::Point; diff --git a/examples/tour/src/main.rs b/examples/tour/src/main.rs index d4b41310..63062e7c 100644 --- a/examples/tour/src/main.rs +++ b/examples/tour/src/main.rs @@ -1,7 +1,8 @@ use iced::{ - alignment, button, scrollable, slider, text_input, Button, Checkbox, Color, - Column, Container, Element, Image, Length, Radio, Row, Sandbox, Scrollable, - Settings, Slider, Space, Text, TextInput, Toggler, + alignment, button, image::ContentFit, scrollable, slider, text_input, + Button, Checkbox, Color, Column, Container, Element, Image, Length, Radio, + Row, Sandbox, Scrollable, Settings, Slider, Space, Text, TextInput, + Toggler, }; pub fn main() -> iced::Result { @@ -139,7 +140,8 @@ impl Steps { can_continue: false, }, Step::Image { - width: 300, + height: 200, + current_fit: ContentFit::Contain, slider: slider::State::new(), }, Step::Scrollable, @@ -213,8 +215,9 @@ enum Step { can_continue: bool, }, Image { - width: u16, + height: u16, slider: slider::State, + current_fit: ContentFit, }, Scrollable, TextInput { @@ -234,7 +237,8 @@ pub enum StepMessage { TextSizeChanged(u16), TextColorChanged(Color), LanguageSelected(Language), - ImageWidthChanged(u16), + ImageHeightChanged(u16), + ImageFitSelected(ContentFit), InputChanged(String), ToggleSecureInput(bool), DebugToggled(bool), @@ -279,9 +283,14 @@ impl<'a> Step { *spacing = new_spacing; } } - StepMessage::ImageWidthChanged(new_width) => { - if let Step::Image { width, .. } = self { - *width = new_width; + StepMessage::ImageHeightChanged(new_height) => { + if let Step::Image { height, .. } = self { + *height = new_height; + } + } + StepMessage::ImageFitSelected(fit) => { + if let Step::Image { current_fit, .. } = self { + *current_fit = fit; } } StepMessage::InputChanged(new_value) => { @@ -346,7 +355,11 @@ impl<'a> Step { color_sliders, color, } => Self::text(size_slider, *size, color_sliders, *color), - Step::Image { width, slider } => Self::image(*width, slider), + Step::Image { + height, + slider, + current_fit, + } => Self::image(*height, slider, *current_fit), Step::RowsAndColumns { layout, spacing_slider, @@ -574,23 +587,45 @@ impl<'a> Step { } fn image( - width: u16, + height: u16, slider: &'a mut slider::State, + current_fit: ContentFit, ) -> Column<'a, StepMessage> { + const FIT_MODES: [(ContentFit, &str); 5] = [ + (ContentFit::Contain, "Contain"), + (ContentFit::Cover, "Cover"), + (ContentFit::Fill, "Fill"), + (ContentFit::None, "None"), + (ContentFit::ScaleDown, "Only Scale Down"), + ]; + + let mode_selector = FIT_MODES.iter().fold( + Column::new().padding(10).spacing(20), + |choices, (mode, name)| { + choices.push(Radio::new( + *mode, + *name, + Some(current_fit), + StepMessage::ImageFitSelected, + )) + }, + ); + Self::container("Image") - .push(Text::new("An image that tries to keep its aspect ratio.")) - .push(ferris(width)) + .push(Text::new("Pictures of things in all shapes and sizes!")) + .push(logo(height, current_fit)) .push(Slider::new( slider, - 100..=500, - width, - StepMessage::ImageWidthChanged, + 50..=500, + height, + StepMessage::ImageHeightChanged, )) .push( - Text::new(format!("Width: {} px", width.to_string())) + Text::new(format!("Height: {} px", height)) .width(Length::Fill) .horizontal_alignment(alignment::Horizontal::Center), ) + .push(mode_selector) } fn scrollable() -> Column<'a, StepMessage> { @@ -613,7 +648,7 @@ impl<'a> Step { .horizontal_alignment(alignment::Horizontal::Center), ) .push(Column::new().height(Length::Units(4096))) - .push(ferris(300)) + .push(ferris(200)) .push( Text::new("You made it!") .width(Length::Fill) @@ -699,6 +734,7 @@ impl<'a> Step { } } +/// Passing fit=None defaults to ContentFit::Contain fn ferris<'a>(width: u16) -> Container<'a, StepMessage> { Container::new( // This should go away once we unify resource loading on native @@ -708,10 +744,32 @@ fn ferris<'a>(width: u16) -> Container<'a, StepMessage> { } else { Image::new(format!( "{}/images/ferris.png", - env!("CARGO_MANIFEST_DIR") + env!("CARGO_MANIFEST_DIR"), + )) + } + .width(Length::Units(width)) + .fit(ContentFit::Contain), + ) + .width(Length::Fill) + .center_x() +} + +/// Passing fit=None defaults to ContentFit::Contain +fn logo<'a>(height: u16, fit: ContentFit) -> Container<'a, StepMessage> { + Container::new( + // This should go away once we unify resource loading on native + // platforms + if cfg!(target_arch = "wasm32") { + Image::new("tour/images/logo.png") + } else { + Image::new(format!( + "{}/images/logo.png", + env!("CARGO_MANIFEST_DIR"), )) } - .width(Length::Units(width)), + .width(Length::Fill) + .height(Length::Units(height)) + .fit(fit), ) .width(Length::Fill) .center_x() diff --git a/native/src/lib.rs b/native/src/lib.rs index 6d98f7d1..5c9c24c9 100644 --- a/native/src/lib.rs +++ b/native/src/lib.rs @@ -71,8 +71,8 @@ mod debug; pub use iced_core::alignment; pub use iced_core::time; pub use iced_core::{ - Alignment, Background, Color, Font, Length, Padding, Point, Rectangle, - Size, Vector, + Alignment, Background, Color, ContentFit, Font, Length, Padding, Point, + Rectangle, Size, Vector, }; pub use iced_futures::{executor, futures}; diff --git a/native/src/widget/image.rs b/native/src/widget/image.rs index b8fb662e..5ddc3642 100644 --- a/native/src/widget/image.rs +++ b/native/src/widget/image.rs @@ -5,7 +5,9 @@ pub use viewer::Viewer; use crate::image; use crate::layout; use crate::renderer; -use crate::{Element, Hasher, Layout, Length, Point, Rectangle, Size, Widget}; +use crate::{ + ContentFit, Element, Hasher, Layout, Length, Point, Rectangle, Size, Widget, +}; use std::hash::Hash; @@ -26,6 +28,7 @@ pub struct Image { handle: Handle, width: Length, height: Length, + fit: ContentFit, } impl Image { @@ -35,6 +38,7 @@ impl Image { handle: handle.into(), width: Length::Shrink, height: Length::Shrink, + fit: ContentFit::Contain, } } @@ -49,6 +53,13 @@ impl Image { self.height = height; self } + + /// Sets the image fit + /// + /// Defaults to [`ContentFit::Contain`] + pub fn fit(self, fit: ContentFit) -> Self { + Self { fit, ..self } + } } impl Widget for Image @@ -69,24 +80,32 @@ where renderer: &Renderer, limits: &layout::Limits, ) -> layout::Node { + // The raw w/h of the underlying image let (width, height) = renderer.dimensions(&self.handle); + let image_size = Size::new(width as f32, height as f32); - let aspect_ratio = width as f32 / height as f32; - - let mut size = limits + // The size to be available to the widget prior to `Shrink`ing + let raw_size = limits .width(self.width) .height(self.height) - .resolve(Size::new(width as f32, height as f32)); - - let viewport_aspect_ratio = size.width / size.height; - - if viewport_aspect_ratio > aspect_ratio { - size.width = width as f32 * size.height / height as f32; - } else { - size.height = height as f32 * size.width / width as f32; - } - - layout::Node::new(size) + .resolve(image_size); + + // The uncropped size of the image when fit to the bounds above + let full_size = self.fit.fit(image_size, raw_size); + + // Shrink the widget to fit the resized image, if requested + let final_size = Size { + width: match self.width { + Length::Shrink => f32::min(raw_size.width, full_size.width), + _ => raw_size.width, + }, + height: match self.height { + Length::Shrink => f32::min(raw_size.height, full_size.height), + _ => raw_size.height, + }, + }; + + layout::Node::new(final_size) } fn draw( @@ -97,7 +116,22 @@ where _cursor_position: Point, _viewport: &Rectangle, ) { - renderer.draw(self.handle.clone(), layout.bounds()); + // The raw w/h of the underlying image + let (width, height) = renderer.dimensions(&self.handle); + let image_size = Size::new(width as f32, height as f32); + + let adjusted_fit = self.fit.fit(image_size, layout.bounds().size()); + + renderer.with_layer(layout.bounds(), |renderer| { + renderer.draw( + self.handle.clone(), + Rectangle { + width: adjusted_fit.width, + height: adjusted_fit.height, + ..layout.bounds() + }, + ) + }) } fn hash_layout(&self, state: &mut Hasher) { diff --git a/src/widget.rs b/src/widget.rs index c619bcfa..d27e4c72 100644 --- a/src/widget.rs +++ b/src/widget.rs @@ -39,6 +39,7 @@ pub mod image { pub use crate::runtime::image::Handle; pub use crate::runtime::widget::image::viewer; pub use crate::runtime::widget::image::{Image, Viewer}; + pub use crate::runtime::ContentFit; } #[cfg_attr(docsrs, doc(cfg(feature = "svg")))] -- cgit From c6486978de7f47577c85ed18ccb28a760381d421 Mon Sep 17 00:00:00 2001 From: Héctor Ramón Jiménez Date: Wed, 16 Feb 2022 17:28:04 +0700 Subject: Rename `image` module to `content_fit` in `iced_core` Since we are just exposing the `ContentFit` type and not the module `image` at all. --- core/src/content_fit.rs | 119 ++++++++++++++++++++++++++++++++++++++++++++++++ core/src/image.rs | 119 ------------------------------------------------ core/src/lib.rs | 4 +- 3 files changed, 121 insertions(+), 121 deletions(-) create mode 100644 core/src/content_fit.rs delete mode 100644 core/src/image.rs diff --git a/core/src/content_fit.rs b/core/src/content_fit.rs new file mode 100644 index 00000000..6bbedc7a --- /dev/null +++ b/core/src/content_fit.rs @@ -0,0 +1,119 @@ +//! Control the fit of some content (like an image) within a space. +use crate::Size; + +/// The strategy used to fit the contents of a widget to its bounding box. +/// +/// Each variant of this enum is a strategy that can be applied for resolving +/// differences in aspect ratio and size between the image being displayed and +/// the space its being displayed in. +/// +/// For an interactive demonstration of these properties as they are implemented +/// in CSS, see [Mozilla's docs][1], or run the `tour` example +/// +/// [1]: https://developer.mozilla.org/en-US/docs/Web/CSS/object-fit +#[derive(Debug, Hash, Clone, Copy, PartialEq, Eq)] +pub enum ContentFit { + /// Scale as big as it can be without needing to crop or hide parts. + /// + /// The image will be scaled (preserving aspect ratio) so that it just fits + /// within the window. This won't distort the image or crop/hide any edges, + /// but if the image doesn't fit perfectly, there may be whitespace on the + /// top/bottom or left/right. + /// + /// This is a great fit for when you need to display an image without losing + /// any part of it, particularly when the image itself is the focus of the + /// screen. + Contain, + + /// Scale the image to cover all of the bounding box, cropping if needed. + /// + /// This doesn't distort the image, and it ensures that the widget's area is + /// completely covered, but it might crop off a bit of the edges of the + /// widget, particularly when there is a big difference between the aspect + /// ratio of the widget and the aspect ratio of the image. + /// + /// This is best for when you're using an image as a background, or to fill + /// space, and any details of the image around the edge aren't too + /// important. + Cover, + + /// Distort the image so the widget is 100% covered without cropping. + /// + /// This stretches the image to fit the widget, without any whitespace or + /// cropping. However, because of the stretch, the image may look distorted + /// or elongated, particularly when there's a mismatch of aspect ratios. + Fill, + + /// Don't resize or scale the image at all. + /// + /// This will not apply any transformations to the provided image, but also + /// means that unless you do the math yourself, the widget's area will not + /// be completely covered, or the image might be cropped. + /// + /// This is best for when you've sized the image yourself. + None, + + /// Scale the image down if it's too big for the space, but never scale it + /// up. + /// + /// This works much like [`Contain`](Self::Contain), except that if the + /// image would have been scaled up, it keeps its original resolution to + /// avoid the bluring that accompanies upscaling images. + ScaleDown, +} + +impl ContentFit { + /// Attempt to apply the given fit for a content size within some bounds. + /// + /// The returned value is the recommended scaled size of the content. + pub fn fit(&self, content: Size, bounds: Size) -> Size { + let content_ar = content.width / content.height; + let bounds_ar = bounds.width / bounds.height; + + match self { + Self::Contain => { + if bounds_ar > content_ar { + Size { + width: content.width * bounds.height / content.height, + ..bounds + } + } else { + Size { + height: content.height * bounds.width / content.width, + ..bounds + } + } + } + Self::Cover => { + if bounds_ar < content_ar { + Size { + width: content.width * bounds.height / content.height, + ..bounds + } + } else { + Size { + height: content.height * bounds.width / content.width, + ..bounds + } + } + } + Self::Fill => bounds, + Self::None => content, + Self::ScaleDown => { + if bounds_ar > content_ar && bounds.height < content.height { + Size { + width: content.width * bounds.height / content.height, + ..bounds + } + } else if bounds.width < content.width { + Size { + height: content.height * bounds.width / content.width, + ..bounds + } + } else { + content + } + } + } + } +} diff --git a/core/src/image.rs b/core/src/image.rs deleted file mode 100644 index 97a9eb2c..00000000 --- a/core/src/image.rs +++ /dev/null @@ -1,119 +0,0 @@ -//! Control the fit of some content (like an image) within a space - -use crate::Size; - -/// How the image should scale to fit the bounding box of the widget -/// -/// Each variant of this enum is a strategy that can be applied for resolving -/// differences in aspect ratio and size between the image being displayed and -/// the space its being displayed in. -/// -/// For an interactive demonstration of these properties as they are implemented -/// in CSS, see [Mozilla's docs][1], or run the `tour` example -/// -/// [1]: https://developer.mozilla.org/en-US/docs/Web/CSS/object-fit -#[derive(Debug, Hash, Clone, Copy, PartialEq, Eq)] -pub enum ContentFit { - /// Scale as big as it can be without needing to crop or hide parts - /// - /// The image will be scaled (preserving aspect ratio) so that it just fits - /// within the window. This won't distort the image or crop/hide any edges, - /// but if the image doesn't fit perfectly, there may be whitespace on the - /// top/bottom or left/right. - /// - /// This is a great fit for when you need to display an image without losing - /// any part of it, particularly when the image itself is the focus of the - /// screen. - Contain, - - /// Scale the image to cover all of the bounding box, cropping if needed - /// - /// This doesn't distort the image, and it ensures that the widget's area is - /// completely covered, but it might crop off a bit of the edges of the - /// widget, particularly when there is a big difference between the aspect - /// ratio of the widget and the aspect ratio of the image. - /// - /// This is best for when you're using an image as a background, or to fill - /// space, and any details of the image around the edge aren't too - /// important. - Cover, - - /// Distort the image so the widget is 100% covered without cropping - /// - /// This stretches the image to fit the widget, without any whitespace or - /// cropping. However, because of the stretch, the image may look distorted - /// or elongated, particularly when there's a mismatch of aspect ratios. - Fill, - - /// Don't resize or scale the image at all - /// - /// This will not apply any transformations to the provided image, but also - /// means that unless you do the math yourself, the widget's area will not - /// be completely covered, or the image might be cropped. - /// - /// This is best for when you've sized the image yourself. - None, - - /// Scale the image down if it's too big for the space, but never scale it up - /// - /// This works much like [`Contain`](Self::Contain), except that if the - /// image would have been scaled up, it keeps its original resolution to - /// avoid the bluring that accompanies upscaling images. - ScaleDown, -} - -impl ContentFit { - /// Attempt to apply the given fit for a content size within some bounds - /// - /// The returned value is the recommended scaled size of the content. - pub fn fit(&self, content: Size, bounds: Size) -> Size { - let content_ar = content.width / content.height; - let bounds_ar = bounds.width / bounds.height; - - match self { - Self::Contain => { - if bounds_ar > content_ar { - Size { - width: content.width * bounds.height / content.height, - ..bounds - } - } else { - Size { - height: content.height * bounds.width / content.width, - ..bounds - } - } - } - Self::Cover => { - if bounds_ar < content_ar { - Size { - width: content.width * bounds.height / content.height, - ..bounds - } - } else { - Size { - height: content.height * bounds.width / content.width, - ..bounds - } - } - } - Self::Fill => bounds, - Self::None => content, - Self::ScaleDown => { - if bounds_ar > content_ar && bounds.height < content.height { - Size { - width: content.width * bounds.height / content.height, - ..bounds - } - } else if bounds.width < content.width { - Size { - height: content.height * bounds.width / content.width, - ..bounds - } - } else { - content - } - } - } - } -} diff --git a/core/src/lib.rs b/core/src/lib.rs index 0eac97c2..3eb9f659 100644 --- a/core/src/lib.rs +++ b/core/src/lib.rs @@ -21,8 +21,8 @@ pub mod time; mod background; mod color; +mod content_fit; mod font; -mod image; mod length; mod padding; mod point; @@ -33,8 +33,8 @@ mod vector; pub use alignment::Alignment; pub use background::Background; pub use color::Color; +pub use content_fit::ContentFit; pub use font::Font; -pub use image::ContentFit; pub use length::Length; pub use padding::Padding; pub use point::Point; -- cgit From 395eacfc103e3123a10bebe4a9330f7c126650a4 Mon Sep 17 00:00:00 2001 From: Héctor Ramón Jiménez Date: Wed, 16 Feb 2022 17:35:28 +0700 Subject: Use a new clipping layer only when necessary in `Image::draw` --- native/src/widget/image.rs | 13 +++++++++++-- 1 file changed, 11 insertions(+), 2 deletions(-) diff --git a/native/src/widget/image.rs b/native/src/widget/image.rs index 5ddc3642..b253b1b8 100644 --- a/native/src/widget/image.rs +++ b/native/src/widget/image.rs @@ -121,8 +121,9 @@ where let image_size = Size::new(width as f32, height as f32); let adjusted_fit = self.fit.fit(image_size, layout.bounds().size()); + let bounds = layout.bounds(); - renderer.with_layer(layout.bounds(), |renderer| { + let render = |renderer: &mut Renderer| { renderer.draw( self.handle.clone(), Rectangle { @@ -131,7 +132,15 @@ where ..layout.bounds() }, ) - }) + }; + + if adjusted_fit.width > bounds.width + || adjusted_fit.height > bounds.height + { + renderer.with_layer(layout.bounds(), render); + } else { + render(renderer) + } } fn hash_layout(&self, state: &mut Hasher) { -- cgit From 8b5c9dfa71f770281ca277163c320571c39ee572 Mon Sep 17 00:00:00 2001 From: Héctor Ramón Jiménez Date: Wed, 16 Feb 2022 17:37:24 +0700 Subject: Make documentation of `Image::fit` consistent --- native/src/widget/image.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/native/src/widget/image.rs b/native/src/widget/image.rs index b253b1b8..f2b8ef2f 100644 --- a/native/src/widget/image.rs +++ b/native/src/widget/image.rs @@ -54,7 +54,7 @@ impl Image { self } - /// Sets the image fit + /// Sets the [`ContentFit`] of the [`Image`]. /// /// Defaults to [`ContentFit::Contain`] pub fn fit(self, fit: ContentFit) -> Self { -- cgit From 0aff444941f8b44b5a996dde4810ba6313f43a7e Mon Sep 17 00:00:00 2001 From: Héctor Ramón Jiménez Date: Wed, 16 Feb 2022 17:51:03 +0700 Subject: Rename `Image::fit` to `content_fit` ... just for consistency! --- examples/tour/src/main.rs | 4 ++-- native/src/widget/image.rs | 16 ++++++++++------ 2 files changed, 12 insertions(+), 8 deletions(-) diff --git a/examples/tour/src/main.rs b/examples/tour/src/main.rs index 63062e7c..0c61add0 100644 --- a/examples/tour/src/main.rs +++ b/examples/tour/src/main.rs @@ -748,7 +748,7 @@ fn ferris<'a>(width: u16) -> Container<'a, StepMessage> { )) } .width(Length::Units(width)) - .fit(ContentFit::Contain), + .content_fit(ContentFit::Contain), ) .width(Length::Fill) .center_x() @@ -769,7 +769,7 @@ fn logo<'a>(height: u16, fit: ContentFit) -> Container<'a, StepMessage> { } .width(Length::Fill) .height(Length::Units(height)) - .fit(fit), + .content_fit(fit), ) .width(Length::Fill) .center_x() diff --git a/native/src/widget/image.rs b/native/src/widget/image.rs index f2b8ef2f..d83230f2 100644 --- a/native/src/widget/image.rs +++ b/native/src/widget/image.rs @@ -28,7 +28,7 @@ pub struct Image { handle: Handle, width: Length, height: Length, - fit: ContentFit, + content_fit: ContentFit, } impl Image { @@ -38,7 +38,7 @@ impl Image { handle: handle.into(), width: Length::Shrink, height: Length::Shrink, - fit: ContentFit::Contain, + content_fit: ContentFit::Contain, } } @@ -57,8 +57,11 @@ impl Image { /// Sets the [`ContentFit`] of the [`Image`]. /// /// Defaults to [`ContentFit::Contain`] - pub fn fit(self, fit: ContentFit) -> Self { - Self { fit, ..self } + pub fn content_fit(self, content_fit: ContentFit) -> Self { + Self { + content_fit, + ..self + } } } @@ -91,7 +94,7 @@ where .resolve(image_size); // The uncropped size of the image when fit to the bounds above - let full_size = self.fit.fit(image_size, raw_size); + let full_size = self.content_fit.fit(image_size, raw_size); // Shrink the widget to fit the resized image, if requested let final_size = Size { @@ -120,7 +123,8 @@ where let (width, height) = renderer.dimensions(&self.handle); let image_size = Size::new(width as f32, height as f32); - let adjusted_fit = self.fit.fit(image_size, layout.bounds().size()); + let adjusted_fit = + self.content_fit.fit(image_size, layout.bounds().size()); let bounds = layout.bounds(); let render = |renderer: &mut Renderer| { -- cgit From 6822d1d9f2c5b4fcbf65763c8edd091ac18a657e Mon Sep 17 00:00:00 2001 From: Héctor Ramón Jiménez Date: Wed, 16 Feb 2022 17:52:57 +0700 Subject: Center `Image` inside available bounds when possible --- native/src/widget/image.rs | 23 ++++++++++++++--------- 1 file changed, 14 insertions(+), 9 deletions(-) diff --git a/native/src/widget/image.rs b/native/src/widget/image.rs index d83230f2..a2e7f765 100644 --- a/native/src/widget/image.rs +++ b/native/src/widget/image.rs @@ -6,7 +6,8 @@ use crate::image; use crate::layout; use crate::renderer; use crate::{ - ContentFit, Element, Hasher, Layout, Length, Point, Rectangle, Size, Widget, + ContentFit, Element, Hasher, Layout, Length, Point, Rectangle, Size, + Vector, Widget, }; use std::hash::Hash; @@ -128,14 +129,18 @@ where let bounds = layout.bounds(); let render = |renderer: &mut Renderer| { - renderer.draw( - self.handle.clone(), - Rectangle { - width: adjusted_fit.width, - height: adjusted_fit.height, - ..layout.bounds() - }, - ) + let offset = Vector::new( + (bounds.width - adjusted_fit.width).max(0.0) / 2.0, + (bounds.height - adjusted_fit.height).max(0.0) / 2.0, + ); + + let bounds = Rectangle { + width: adjusted_fit.width, + height: adjusted_fit.height, + ..layout.bounds() + }; + + renderer.draw(self.handle.clone(), bounds + offset) }; if adjusted_fit.width > bounds.width -- cgit From c910e239196655f3d5ba146aa3dc8da2b578ef8e Mon Sep 17 00:00:00 2001 From: Héctor Ramón Jiménez Date: Wed, 16 Feb 2022 17:58:51 +0700 Subject: Expose `ContentFit` in root --- examples/tour/src/main.rs | 7 +++---- src/lib.rs | 4 ++-- src/widget.rs | 1 - 3 files changed, 5 insertions(+), 7 deletions(-) diff --git a/examples/tour/src/main.rs b/examples/tour/src/main.rs index 0c61add0..9a675168 100644 --- a/examples/tour/src/main.rs +++ b/examples/tour/src/main.rs @@ -1,8 +1,7 @@ use iced::{ - alignment, button, image::ContentFit, scrollable, slider, text_input, - Button, Checkbox, Color, Column, Container, Element, Image, Length, Radio, - Row, Sandbox, Scrollable, Settings, Slider, Space, Text, TextInput, - Toggler, + alignment, button, scrollable, slider, text_input, Button, Checkbox, Color, + Column, Container, ContentFit, Element, Image, Length, Radio, Row, Sandbox, + Scrollable, Settings, Slider, Space, Text, TextInput, Toggler, }; pub fn main() -> iced::Result { diff --git a/src/lib.rs b/src/lib.rs index c8047d7f..b34bb72c 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -221,6 +221,6 @@ pub use settings::Settings; pub use runtime::alignment; pub use runtime::futures; pub use runtime::{ - Alignment, Background, Color, Command, Font, Length, Point, Rectangle, - Size, Subscription, Vector, + Alignment, Background, Color, Command, ContentFit, Font, Length, Point, + Rectangle, Size, Subscription, Vector, }; diff --git a/src/widget.rs b/src/widget.rs index d27e4c72..c619bcfa 100644 --- a/src/widget.rs +++ b/src/widget.rs @@ -39,7 +39,6 @@ pub mod image { pub use crate::runtime::image::Handle; pub use crate::runtime::widget::image::viewer; pub use crate::runtime::widget::image::{Image, Viewer}; - pub use crate::runtime::ContentFit; } #[cfg_attr(docsrs, doc(cfg(feature = "svg")))] -- cgit From 83c0e0f7a862ddcefedfb4ef11a11f9bd5245605 Mon Sep 17 00:00:00 2001 From: Héctor Ramón Jiménez Date: Wed, 16 Feb 2022 17:59:39 +0700 Subject: Add `ContentFit` support to `Svg` widget --- native/src/widget/image.rs | 1 - native/src/widget/svg.rs | 83 +++++++++++++++++++++++++++++++++++++--------- 2 files changed, 67 insertions(+), 17 deletions(-) diff --git a/native/src/widget/image.rs b/native/src/widget/image.rs index a2e7f765..8ccc7856 100644 --- a/native/src/widget/image.rs +++ b/native/src/widget/image.rs @@ -120,7 +120,6 @@ where _cursor_position: Point, _viewport: &Rectangle, ) { - // The raw w/h of the underlying image let (width, height) = renderer.dimensions(&self.handle); let image_size = Size::new(width as f32, height as f32); diff --git a/native/src/widget/svg.rs b/native/src/widget/svg.rs index f212dfcb..9e3639db 100644 --- a/native/src/widget/svg.rs +++ b/native/src/widget/svg.rs @@ -2,7 +2,10 @@ use crate::layout; use crate::renderer; use crate::svg::{self, Handle}; -use crate::{Element, Hasher, Layout, Length, Point, Rectangle, Size, Widget}; +use crate::{ + ContentFit, Element, Hasher, Layout, Length, Point, Rectangle, Size, + Vector, Widget, +}; use std::hash::Hash; use std::path::PathBuf; @@ -18,6 +21,7 @@ pub struct Svg { handle: Handle, width: Length, height: Length, + content_fit: ContentFit, } impl Svg { @@ -27,6 +31,7 @@ impl Svg { handle: handle.into(), width: Length::Fill, height: Length::Shrink, + content_fit: ContentFit::Contain, } } @@ -47,6 +52,16 @@ impl Svg { self.height = height; self } + + /// Sets the [`ContentFit`] of the [`Svg`]. + /// + /// Defaults to [`ContentFit::Contain`] + pub fn content_fit(self, content_fit: ContentFit) -> Self { + Self { + content_fit, + ..self + } + } } impl Widget for Svg @@ -66,24 +81,32 @@ where renderer: &Renderer, limits: &layout::Limits, ) -> layout::Node { + // The raw w/h of the underlying image let (width, height) = renderer.dimensions(&self.handle); + let image_size = Size::new(width as f32, height as f32); - let aspect_ratio = width as f32 / height as f32; - - let mut size = limits + // The size to be available to the widget prior to `Shrink`ing + let raw_size = limits .width(self.width) .height(self.height) - .resolve(Size::new(width as f32, height as f32)); - - let viewport_aspect_ratio = size.width / size.height; - - if viewport_aspect_ratio > aspect_ratio { - size.width = width as f32 * size.height / height as f32; - } else { - size.height = height as f32 * size.width / width as f32; - } - - layout::Node::new(size) + .resolve(image_size); + + // The uncropped size of the image when fit to the bounds above + let full_size = self.content_fit.fit(image_size, raw_size); + + // Shrink the widget to fit the resized image, if requested + let final_size = Size { + width: match self.width { + Length::Shrink => f32::min(raw_size.width, full_size.width), + _ => raw_size.width, + }, + height: match self.height { + Length::Shrink => f32::min(raw_size.height, full_size.height), + _ => raw_size.height, + }, + }; + + layout::Node::new(final_size) } fn draw( @@ -94,7 +117,35 @@ where _cursor_position: Point, _viewport: &Rectangle, ) { - renderer.draw(self.handle.clone(), layout.bounds()) + let (width, height) = renderer.dimensions(&self.handle); + let image_size = Size::new(width as f32, height as f32); + + let adjusted_fit = + self.content_fit.fit(image_size, layout.bounds().size()); + let bounds = layout.bounds(); + + let render = |renderer: &mut Renderer| { + let offset = Vector::new( + (bounds.width - adjusted_fit.width).max(0.0) / 2.0, + (bounds.height - adjusted_fit.height).max(0.0) / 2.0, + ); + + let bounds = Rectangle { + width: adjusted_fit.width, + height: adjusted_fit.height, + ..layout.bounds() + }; + + renderer.draw(self.handle.clone(), bounds + offset) + }; + + if adjusted_fit.width > bounds.width + || adjusted_fit.height > bounds.height + { + renderer.with_layer(layout.bounds(), render); + } else { + render(renderer) + } } fn hash_layout(&self, state: &mut Hasher) { -- cgit From 8d94cd4c5c9e33965c24e59fd4710218e346be24 Mon Sep 17 00:00:00 2001 From: Héctor Ramón Jiménez Date: Wed, 16 Feb 2022 18:09:22 +0700 Subject: Remove redundant `layout.bounds()` calls in `Image` and `Svg` --- native/src/widget/image.rs | 11 +++++------ native/src/widget/svg.rs | 11 +++++------ 2 files changed, 10 insertions(+), 12 deletions(-) diff --git a/native/src/widget/image.rs b/native/src/widget/image.rs index 8ccc7856..6aab76e4 100644 --- a/native/src/widget/image.rs +++ b/native/src/widget/image.rs @@ -123,9 +123,8 @@ where let (width, height) = renderer.dimensions(&self.handle); let image_size = Size::new(width as f32, height as f32); - let adjusted_fit = - self.content_fit.fit(image_size, layout.bounds().size()); let bounds = layout.bounds(); + let adjusted_fit = self.content_fit.fit(image_size, bounds.size()); let render = |renderer: &mut Renderer| { let offset = Vector::new( @@ -133,19 +132,19 @@ where (bounds.height - adjusted_fit.height).max(0.0) / 2.0, ); - let bounds = Rectangle { + let drawing_bounds = Rectangle { width: adjusted_fit.width, height: adjusted_fit.height, - ..layout.bounds() + ..bounds }; - renderer.draw(self.handle.clone(), bounds + offset) + renderer.draw(self.handle.clone(), drawing_bounds + offset) }; if adjusted_fit.width > bounds.width || adjusted_fit.height > bounds.height { - renderer.with_layer(layout.bounds(), render); + renderer.with_layer(bounds, render); } else { render(renderer) } diff --git a/native/src/widget/svg.rs b/native/src/widget/svg.rs index 9e3639db..5ce8d25b 100644 --- a/native/src/widget/svg.rs +++ b/native/src/widget/svg.rs @@ -120,9 +120,8 @@ where let (width, height) = renderer.dimensions(&self.handle); let image_size = Size::new(width as f32, height as f32); - let adjusted_fit = - self.content_fit.fit(image_size, layout.bounds().size()); let bounds = layout.bounds(); + let adjusted_fit = self.content_fit.fit(image_size, bounds.size()); let render = |renderer: &mut Renderer| { let offset = Vector::new( @@ -130,19 +129,19 @@ where (bounds.height - adjusted_fit.height).max(0.0) / 2.0, ); - let bounds = Rectangle { + let drawing_bounds = Rectangle { width: adjusted_fit.width, height: adjusted_fit.height, - ..layout.bounds() + ..bounds }; - renderer.draw(self.handle.clone(), bounds + offset) + renderer.draw(self.handle.clone(), drawing_bounds + offset) }; if adjusted_fit.width > bounds.width || adjusted_fit.height > bounds.height { - renderer.with_layer(layout.bounds(), render); + renderer.with_layer(bounds, render); } else { render(renderer) } -- cgit From 15b4bbd49dfb4f70e1e73699958a764c0568b452 Mon Sep 17 00:00:00 2001 From: Héctor Ramón Jiménez Date: Wed, 16 Feb 2022 18:16:09 +0700 Subject: Hash `content_fit` in `hash_layout` of `Image` and `Svg` --- native/src/widget/image.rs | 1 + native/src/widget/svg.rs | 1 + 2 files changed, 2 insertions(+) diff --git a/native/src/widget/image.rs b/native/src/widget/image.rs index 6aab76e4..83c24ee5 100644 --- a/native/src/widget/image.rs +++ b/native/src/widget/image.rs @@ -157,6 +157,7 @@ where self.handle.hash(state); self.width.hash(state); self.height.hash(state); + self.content_fit.hash(state); } } diff --git a/native/src/widget/svg.rs b/native/src/widget/svg.rs index 5ce8d25b..22aac331 100644 --- a/native/src/widget/svg.rs +++ b/native/src/widget/svg.rs @@ -153,6 +153,7 @@ where self.handle.hash(state); self.width.hash(state); self.height.hash(state); + self.content_fit.hash(state); } } -- cgit From 6f6ce15a2055ddbc15dbe71bc811dbe1c8f42068 Mon Sep 17 00:00:00 2001 From: Héctor Ramón Jiménez Date: Wed, 16 Feb 2022 18:16:22 +0700 Subject: Keep using Ferris in the image section of the `tour` Wide ferris is cute :3 --- examples/tour/src/main.rs | 33 +++++++-------------------------- 1 file changed, 7 insertions(+), 26 deletions(-) diff --git a/examples/tour/src/main.rs b/examples/tour/src/main.rs index 9a675168..a4863724 100644 --- a/examples/tour/src/main.rs +++ b/examples/tour/src/main.rs @@ -612,7 +612,7 @@ impl<'a> Step { Self::container("Image") .push(Text::new("Pictures of things in all shapes and sizes!")) - .push(logo(height, current_fit)) + .push(ferris(height, current_fit)) .push(Slider::new( slider, 50..=500, @@ -647,7 +647,7 @@ impl<'a> Step { .horizontal_alignment(alignment::Horizontal::Center), ) .push(Column::new().height(Length::Units(4096))) - .push(ferris(200)) + .push(ferris(200, ContentFit::Contain)) .push( Text::new("You made it!") .width(Length::Fill) @@ -733,8 +733,10 @@ impl<'a> Step { } } -/// Passing fit=None defaults to ContentFit::Contain -fn ferris<'a>(width: u16) -> Container<'a, StepMessage> { +fn ferris<'a>( + height: u16, + content_fit: ContentFit, +) -> Container<'a, StepMessage> { Container::new( // This should go away once we unify resource loading on native // platforms @@ -746,29 +748,8 @@ fn ferris<'a>(width: u16) -> Container<'a, StepMessage> { env!("CARGO_MANIFEST_DIR"), )) } - .width(Length::Units(width)) - .content_fit(ContentFit::Contain), - ) - .width(Length::Fill) - .center_x() -} - -/// Passing fit=None defaults to ContentFit::Contain -fn logo<'a>(height: u16, fit: ContentFit) -> Container<'a, StepMessage> { - Container::new( - // This should go away once we unify resource loading on native - // platforms - if cfg!(target_arch = "wasm32") { - Image::new("tour/images/logo.png") - } else { - Image::new(format!( - "{}/images/logo.png", - env!("CARGO_MANIFEST_DIR"), - )) - } - .width(Length::Fill) .height(Length::Units(height)) - .content_fit(fit), + .content_fit(content_fit), ) .width(Length::Fill) .center_x() -- cgit From a12a92c266ee0127456ae3711b246f9148e65f72 Mon Sep 17 00:00:00 2001 From: Nick Senger Date: Tue, 22 Feb 2022 15:02:47 +0700 Subject: fix: overlay layout for `Responsive` --- lazy/src/responsive.rs | 13 +++++++++---- 1 file changed, 9 insertions(+), 4 deletions(-) diff --git a/lazy/src/responsive.rs b/lazy/src/responsive.rs index 35ad6974..d01cfd68 100644 --- a/lazy/src/responsive.rs +++ b/lazy/src/responsive.rs @@ -178,7 +178,7 @@ where let content_layout = state.layout(layout); match content { - Content::Pending(_) => false, + Content::Pending(_) => None, Content::Ready(cache) => { *cache = Some( CacheBuilder { @@ -190,14 +190,19 @@ where .build(), ); - cache.as_ref().unwrap().borrow_overlay().is_some() + cache + .as_ref() + .unwrap() + .borrow_overlay() + .as_ref() + .map(|overlay| overlay.position()) } } }; - has_overlay.then(|| { + has_overlay.map(|position| { overlay::Element::new( - layout.position(), + position, Box::new(Overlay { instance: self }), ) }) -- cgit From 33b9b50883dfcc9838f7792d884324aaffef0a41 Mon Sep 17 00:00:00 2001 From: Héctor Ramón Jiménez Date: Wed, 23 Feb 2022 16:32:12 +0700 Subject: Showcase only `Contain`, `Cover`, and `Fill` image modes in `tour` --- examples/tour/src/main.rs | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/examples/tour/src/main.rs b/examples/tour/src/main.rs index a4863724..e199c88c 100644 --- a/examples/tour/src/main.rs +++ b/examples/tour/src/main.rs @@ -590,12 +590,10 @@ impl<'a> Step { slider: &'a mut slider::State, current_fit: ContentFit, ) -> Column<'a, StepMessage> { - const FIT_MODES: [(ContentFit, &str); 5] = [ + const FIT_MODES: [(ContentFit, &str); 3] = [ (ContentFit::Contain, "Contain"), (ContentFit::Cover, "Cover"), (ContentFit::Fill, "Fill"), - (ContentFit::None, "None"), - (ContentFit::ScaleDown, "Only Scale Down"), ]; let mode_selector = FIT_MODES.iter().fold( @@ -624,6 +622,7 @@ impl<'a> Step { .width(Length::Fill) .horizontal_alignment(alignment::Horizontal::Center), ) + .push(Text::new("Pick a content fit strategy:")) .push(mode_selector) } @@ -821,7 +820,8 @@ pub enum Layout { } mod style { - use iced::{button, Background, Color, Vector}; + use iced::button; + use iced::{Background, Color, Vector}; pub enum Button { Primary, -- cgit From 1313c94e3bb206f064462bc521f78dbffc2a6cd6 Mon Sep 17 00:00:00 2001 From: Héctor Ramón Jiménez Date: Tue, 22 Feb 2022 14:10:49 +0700 Subject: Remove `hash_layout` method from `Widget` trait --- examples/custom_widget/src/main.rs | 10 +- examples/geometry/src/main.rs | 5 +- graphics/src/widget/canvas.rs | 13 +- graphics/src/widget/qr_code.rs | 9 +- lazy/src/component.rs | 21 +--- lazy/src/responsive.rs | 45 ++----- native/src/element.rs | 15 +-- native/src/overlay.rs | 15 +-- native/src/overlay/element.rs | 11 +- native/src/overlay/menu.rs | 26 +--- native/src/user_interface.rs | 210 +++++++------------------------ native/src/widget.rs | 15 +-- native/src/widget/button.rs | 14 +-- native/src/widget/checkbox.rs | 13 +- native/src/widget/column.rs | 23 +--- native/src/widget/container.rs | 21 +--- native/src/widget/image.rs | 13 +- native/src/widget/image/viewer.rs | 15 +-- native/src/widget/pane_grid.rs | 19 +-- native/src/widget/pane_grid/content.rs | 12 +- native/src/widget/pane_grid/state.rs | 8 +- native/src/widget/pane_grid/title_bar.rs | 13 +- native/src/widget/pick_list.rs | 22 +--- native/src/widget/progress_bar.rs | 14 +-- native/src/widget/radio.rs | 13 +- native/src/widget/row.rs | 22 +--- native/src/widget/rule.rs | 14 +-- native/src/widget/scrollable.rs | 16 +-- native/src/widget/slider.rs | 12 +- native/src/widget/space.rs | 11 +- native/src/widget/svg.rs | 13 +- native/src/widget/text.rs | 16 +-- native/src/widget/text_input.rs | 15 +-- native/src/widget/toggler.rs | 12 +- native/src/widget/tooltip.rs | 15 +-- 35 files changed, 105 insertions(+), 636 deletions(-) diff --git a/examples/custom_widget/src/main.rs b/examples/custom_widget/src/main.rs index b32cb83d..28edf256 100644 --- a/examples/custom_widget/src/main.rs +++ b/examples/custom_widget/src/main.rs @@ -11,9 +11,7 @@ mod circle { // implemented by `iced_wgpu` and other renderers. use iced_native::layout::{self, Layout}; use iced_native::renderer; - use iced_native::{ - Color, Element, Hasher, Length, Point, Rectangle, Size, Widget, - }; + use iced_native::{Color, Element, Length, Point, Rectangle, Size, Widget}; pub struct Circle { radius: f32, @@ -45,12 +43,6 @@ mod circle { layout::Node::new(Size::new(self.radius * 2.0, self.radius * 2.0)) } - fn hash_layout(&self, state: &mut Hasher) { - use std::hash::Hash; - - self.radius.to_bits().hash(state); - } - fn draw( &self, renderer: &mut Renderer, diff --git a/examples/geometry/src/main.rs b/examples/geometry/src/main.rs index 6ef12013..58dfa3ad 100644 --- a/examples/geometry/src/main.rs +++ b/examples/geometry/src/main.rs @@ -14,8 +14,7 @@ mod rainbow { use iced_graphics::{Backend, Primitive}; use iced_native::{ - layout, Element, Hasher, Layout, Length, Point, Rectangle, Size, - Vector, Widget, + layout, Element, Layout, Length, Point, Rectangle, Size, Vector, Widget, }; pub struct Rainbow; @@ -48,8 +47,6 @@ mod rainbow { layout::Node::new(Size::new(size.width, size.width)) } - fn hash_layout(&self, _state: &mut Hasher) {} - fn draw( &self, renderer: &mut Renderer, diff --git a/graphics/src/widget/canvas.rs b/graphics/src/widget/canvas.rs index 1016bbe3..157aa25c 100644 --- a/graphics/src/widget/canvas.rs +++ b/graphics/src/widget/canvas.rs @@ -9,10 +9,9 @@ use crate::{Backend, Primitive}; use iced_native::layout; use iced_native::mouse; use iced_native::{ - Clipboard, Element, Hasher, Layout, Length, Point, Rectangle, Shell, Size, - Vector, Widget, + Clipboard, Element, Layout, Length, Point, Rectangle, Shell, Size, Vector, + Widget, }; -use std::hash::Hash; use std::marker::PhantomData; pub mod event; @@ -226,14 +225,6 @@ where }); }); } - - fn hash_layout(&self, state: &mut Hasher) { - struct Marker; - std::any::TypeId::of::().hash(state); - - self.width.hash(state); - self.height.hash(state); - } } impl<'a, Message, P, B> From> diff --git a/graphics/src/widget/qr_code.rs b/graphics/src/widget/qr_code.rs index 285b8622..907794b7 100644 --- a/graphics/src/widget/qr_code.rs +++ b/graphics/src/widget/qr_code.rs @@ -5,8 +5,7 @@ use crate::Backend; use iced_native::layout; use iced_native::{ - Color, Element, Hasher, Layout, Length, Point, Rectangle, Size, Vector, - Widget, + Color, Element, Layout, Length, Point, Rectangle, Size, Vector, Widget, }; use thiserror::Error; @@ -74,12 +73,6 @@ where )) } - fn hash_layout(&self, state: &mut Hasher) { - use std::hash::Hash; - - self.state.contents.hash(state); - } - fn draw( &self, renderer: &mut Renderer, diff --git a/lazy/src/component.rs b/lazy/src/component.rs index 00c27989..9e5937e9 100644 --- a/lazy/src/component.rs +++ b/lazy/src/component.rs @@ -7,12 +7,11 @@ use iced_native::mouse; use iced_native::overlay; use iced_native::renderer; use iced_native::{ - Clipboard, Element, Hasher, Length, Point, Rectangle, Shell, Size, Widget, + Clipboard, Element, Length, Point, Rectangle, Shell, Size, Widget, }; use ouroboros::self_referencing; use std::cell::RefCell; -use std::hash::Hash; use std::marker::PhantomData; /// A reusable, custom widget that uses The Elm Architecture. @@ -217,12 +216,6 @@ where }); } - fn hash_layout(&self, state: &mut Hasher) { - self.with_element(|element| { - element.hash_layout(state); - }); - } - fn mouse_interaction( &self, layout: Layout<'_>, @@ -371,18 +364,6 @@ where .unwrap_or_default() } - fn hash_layout(&self, state: &mut Hasher, position: Point) { - struct Marker; - std::any::TypeId::of::().hash(state); - - (position.x as u32).hash(state); - (position.y as u32).hash(state); - - self.with_overlay_maybe(|overlay| { - overlay.hash_layout(state); - }); - } - fn on_event( &mut self, event: iced_native::Event, diff --git a/lazy/src/responsive.rs b/lazy/src/responsive.rs index d01cfd68..20a80dac 100644 --- a/lazy/src/responsive.rs +++ b/lazy/src/responsive.rs @@ -8,11 +8,10 @@ use iced_native::overlay; use iced_native::renderer; use iced_native::window; use iced_native::{ - Clipboard, Element, Hasher, Length, Point, Rectangle, Shell, Size, Widget, + Clipboard, Element, Length, Point, Rectangle, Shell, Size, Widget, }; use std::cell::RefCell; -use std::hash::{Hash, Hasher as _}; use std::ops::Deref; /// The state of a [`Responsive`] widget. @@ -20,7 +19,6 @@ use std::ops::Deref; pub struct State { last_size: Option, last_layout: layout::Node, - last_layout_hash: u64, } impl State { @@ -76,8 +74,6 @@ where Length::Fill } - fn hash_layout(&self, _hasher: &mut Hasher) {} - fn layout( &self, _renderer: &Renderer, @@ -270,26 +266,13 @@ where let element = view.take().unwrap()(state.last_size.unwrap_or(Size::ZERO)); - let new_layout_hash = { - let mut hasher = Hasher::default(); - element.hash_layout(&mut hasher); - - hasher.finish() - }; - - if state.last_size != Some(state.last_layout.size()) - || new_layout_hash != state.last_layout_hash - { - state.last_layout = element.layout( - renderer.deref(), - &layout::Limits::new( - Size::ZERO, - state.last_size.unwrap_or(Size::ZERO), - ), - ); - - state.last_layout_hash = new_layout_hash; - } + state.last_layout = element.layout( + renderer.deref(), + &layout::Limits::new( + Size::ZERO, + state.last_size.unwrap_or(Size::ZERO), + ), + ); *self = Content::Ready(Some( CacheBuilder { @@ -400,18 +383,6 @@ where .unwrap_or_default() } - fn hash_layout(&self, state: &mut Hasher, position: Point) { - struct Marker; - std::any::TypeId::of::().hash(state); - - (position.x as u32).hash(state); - (position.y as u32).hash(state); - - self.with_overlay_maybe(|overlay| { - overlay.hash_layout(state); - }); - } - fn on_event( &mut self, event: iced_native::Event, diff --git a/native/src/element.rs b/native/src/element.rs index 6afa3f62..119b7892 100644 --- a/native/src/element.rs +++ b/native/src/element.rs @@ -4,7 +4,7 @@ use crate::mouse; use crate::overlay; use crate::renderer; use crate::{ - Clipboard, Color, Hasher, Layout, Length, Point, Rectangle, Shell, Widget, + Clipboard, Color, Layout, Length, Point, Rectangle, Shell, Widget, }; /// A generic [`Widget`]. @@ -269,11 +269,6 @@ where ) } - /// Computes the _layout_ hash of the [`Element`]. - pub fn hash_layout(&self, state: &mut Hasher) { - self.widget.hash_layout(state); - } - /// Returns the overlay of the [`Element`], if there is any. pub fn overlay<'b>( &'b mut self, @@ -379,10 +374,6 @@ where ) } - fn hash_layout(&self, state: &mut Hasher) { - self.widget.hash_layout(state); - } - fn overlay( &mut self, layout: Layout<'_>, @@ -504,10 +495,6 @@ where ) } - fn hash_layout(&self, state: &mut Hasher) { - self.element.widget.hash_layout(state); - } - fn overlay( &mut self, layout: Layout<'_>, diff --git a/native/src/overlay.rs b/native/src/overlay.rs index d4b641af..124bcac2 100644 --- a/native/src/overlay.rs +++ b/native/src/overlay.rs @@ -10,7 +10,7 @@ use crate::event::{self, Event}; use crate::layout; use crate::mouse; use crate::renderer; -use crate::{Clipboard, Hasher, Layout, Point, Rectangle, Shell, Size}; +use crate::{Clipboard, Layout, Point, Rectangle, Shell, Size}; /// An interactive component that can be displayed on top of other widgets. pub trait Overlay @@ -39,19 +39,6 @@ where cursor_position: Point, ); - /// Computes the _layout_ hash of the [`Overlay`]. - /// - /// The produced hash is used by the runtime to decide if the [`Layout`] - /// needs to be recomputed between frames. Therefore, to ensure maximum - /// efficiency, the hash should only be affected by the properties of the - /// [`Overlay`] that can affect layouting. - /// - /// For example, the [`Text`] widget does not hash its color property, as - /// its value cannot affect the overall [`Layout`] of the user interface. - /// - /// [`Text`]: crate::widget::Text - fn hash_layout(&self, state: &mut Hasher, position: Point); - /// Processes a runtime [`Event`]. /// /// It receives: diff --git a/native/src/overlay/element.rs b/native/src/overlay/element.rs index e7621600..b60881e3 100644 --- a/native/src/overlay/element.rs +++ b/native/src/overlay/element.rs @@ -4,7 +4,7 @@ use crate::event::{self, Event}; use crate::layout; use crate::mouse; use crate::renderer; -use crate::{Clipboard, Hasher, Layout, Point, Rectangle, Shell, Size, Vector}; +use crate::{Clipboard, Layout, Point, Rectangle, Shell, Size, Vector}; /// A generic [`Overlay`]. #[allow(missing_debug_implementations)] @@ -100,11 +100,6 @@ where ) { self.overlay.draw(renderer, style, layout, cursor_position) } - - /// Computes the _layout_ hash of the [`Element`]. - pub fn hash_layout(&self, state: &mut Hasher) { - self.overlay.hash_layout(state, self.position); - } } struct Map<'a, A, B, Renderer> { @@ -184,8 +179,4 @@ where ) { self.content.draw(renderer, style, layout, cursor_position) } - - fn hash_layout(&self, state: &mut Hasher, position: Point) { - self.content.hash_layout(state, position); - } } diff --git a/native/src/overlay/menu.rs b/native/src/overlay/menu.rs index 2deef551..13fa7beb 100644 --- a/native/src/overlay/menu.rs +++ b/native/src/overlay/menu.rs @@ -10,8 +10,8 @@ use crate::touch; use crate::widget::scrollable::{self, Scrollable}; use crate::widget::Container; use crate::{ - Clipboard, Color, Element, Hasher, Layout, Length, Padding, Point, - Rectangle, Shell, Size, Vector, Widget, + Clipboard, Color, Element, Layout, Length, Padding, Point, Rectangle, + Shell, Size, Vector, Widget, }; pub use iced_style::menu::Style; @@ -204,17 +204,6 @@ where node } - fn hash_layout(&self, state: &mut Hasher, position: Point) { - use std::hash::Hash; - - struct Marker; - std::any::TypeId::of::().hash(state); - - (position.x as u32).hash(state); - (position.y as u32).hash(state); - self.container.hash_layout(state); - } - fn on_event( &mut self, event: Event, @@ -320,17 +309,6 @@ where layout::Node::new(size) } - fn hash_layout(&self, state: &mut Hasher) { - use std::hash::Hash as _; - - struct Marker; - std::any::TypeId::of::().hash(state); - - self.options.len().hash(state); - self.text_size.hash(state); - self.padding.hash(state); - } - fn on_event( &mut self, event: Event, diff --git a/native/src/user_interface.rs b/native/src/user_interface.rs index f6ec96bb..00015f8b 100644 --- a/native/src/user_interface.rs +++ b/native/src/user_interface.rs @@ -2,12 +2,9 @@ use crate::event::{self, Event}; use crate::layout; use crate::mouse; -use crate::overlay; use crate::renderer; use crate::{Clipboard, Element, Layout, Point, Rectangle, Shell, Size}; -use std::hash::Hasher; - /// A set of interactive graphical elements with a specific [`Layout`]. /// /// It can be updated and drawn. @@ -23,8 +20,8 @@ use std::hash::Hasher; #[allow(missing_debug_implementations)] pub struct UserInterface<'a, Message, Renderer> { root: Element<'a, Message, Renderer>, - base: Layer, - overlay: Option, + base: layout::Node, + overlay: Option, bounds: Size, } @@ -89,41 +86,18 @@ where pub fn build>>( root: E, bounds: Size, - cache: Cache, + _cache: Cache, renderer: &mut Renderer, ) -> Self { let root = root.into(); - let (base, overlay) = { - let hash = { - let hasher = &mut crate::Hasher::default(); - root.hash_layout(hasher); - - hasher.finish() - }; - - let layout_is_cached = - hash == cache.base.hash && bounds == cache.bounds; - - let (layout, overlay) = if layout_is_cached { - (cache.base.layout, cache.overlay) - } else { - ( - renderer.layout( - &root, - &layout::Limits::new(Size::ZERO, bounds), - ), - None, - ) - }; - - (Layer { layout, hash }, overlay) - }; + let base = + renderer.layout(&root, &layout::Limits::new(Size::ZERO, bounds)); UserInterface { root, base, - overlay, + overlay: None, bounds, } } @@ -206,16 +180,10 @@ where let mut state = State::Updated; let (base_cursor, overlay_statuses) = if let Some(mut overlay) = - self.root.overlay(Layout::new(&self.base.layout), renderer) + self.root.overlay(Layout::new(&self.base), renderer) { let bounds = self.bounds; - - let mut layer = Self::overlay_layer( - self.overlay.take(), - bounds, - &mut overlay, - renderer, - ); + let mut layout = overlay.layout(renderer, bounds); let event_statuses = events .iter() @@ -225,7 +193,7 @@ where let event_status = overlay.on_event( event, - Layout::new(&layer.layout), + Layout::new(&layout), cursor_position, renderer, clipboard, @@ -233,12 +201,7 @@ where ); shell.revalidate_layout(|| { - layer = Self::overlay_layer( - None, - bounds, - &mut overlay, - renderer, - ); + layout = overlay.layout(renderer, bounds); }); if shell.are_widgets_invalid() { @@ -249,15 +212,14 @@ where }) .collect(); - let base_cursor = if layer.layout.bounds().contains(cursor_position) - { + let base_cursor = if layout.bounds().contains(cursor_position) { // TODO: Type-safe cursor availability Point::new(-1.0, -1.0) } else { cursor_position }; - self.overlay = Some(layer); + self.overlay = Some(layout); (base_cursor, event_statuses) } else { @@ -273,7 +235,7 @@ where let event_status = self.root.widget.on_event( event, - Layout::new(&self.base.layout), + Layout::new(&self.base), base_cursor, renderer, clipboard, @@ -281,19 +243,11 @@ where ); shell.revalidate_layout(|| { - let hash = { - let hasher = &mut crate::Hasher::default(); - self.root.hash_layout(hasher); - - hasher.finish() - }; - - let layout = renderer.layout( + self.base = renderer.layout( &self.root, &layout::Limits::new(Size::ZERO, self.bounds), ); - self.base = Layer { layout, hash }; self.overlay = None; }); @@ -391,24 +345,8 @@ where let viewport = Rectangle::with_size(self.bounds); - self.overlay = if let Some(mut overlay) = - self.root.overlay(Layout::new(&self.base.layout), renderer) - { - let layer = Self::overlay_layer( - self.overlay.take(), - self.bounds, - &mut overlay, - renderer, - ); - - Some(layer) - } else { - None - }; - - if let Some(layer) = &self.overlay { - let base_cursor = if layer.layout.bounds().contains(cursor_position) - { + if let Some(layout) = &self.overlay { + let base_cursor = if layout.bounds().contains(cursor_position) { Point::new(-1.0, -1.0) } else { cursor_position @@ -417,7 +355,7 @@ where self.root.widget.draw( renderer, &renderer::Style::default(), - Layout::new(&self.base.layout), + Layout::new(&self.base), base_cursor, &viewport, ); @@ -425,14 +363,14 @@ where self.root.widget.draw( renderer, &renderer::Style::default(), - Layout::new(&self.base.layout), + Layout::new(&self.base), cursor_position, &viewport, ); }; let base_interaction = self.root.widget.mouse_interaction( - Layout::new(&self.base.layout), + Layout::new(&self.base), cursor_position, &viewport, renderer, @@ -452,34 +390,32 @@ where // avoid this additional call. overlay .as_ref() - .and_then(|layer| { - root.overlay(Layout::new(&base.layout), renderer).map( - |overlay| { - let overlay_interaction = overlay.mouse_interaction( - Layout::new(&layer.layout), - cursor_position, - &viewport, + .and_then(|layout| { + root.overlay(Layout::new(&base), renderer).map(|overlay| { + let overlay_interaction = overlay.mouse_interaction( + Layout::new(layout), + cursor_position, + &viewport, + renderer, + ); + + let overlay_bounds = layout.bounds(); + + renderer.with_layer(overlay_bounds, |renderer| { + overlay.draw( renderer, + &renderer::Style::default(), + Layout::new(layout), + cursor_position, ); + }); - let overlay_bounds = layer.layout.bounds(); - - renderer.with_layer(overlay_bounds, |renderer| { - overlay.draw( - renderer, - &renderer::Style::default(), - Layout::new(&layer.layout), - cursor_position, - ); - }); - - if overlay_bounds.contains(cursor_position) { - overlay_interaction - } else { - base_interaction - } - }, - ) + if overlay_bounds.contains(cursor_position) { + overlay_interaction + } else { + base_interaction + } + }) }) .unwrap_or(base_interaction) } @@ -487,66 +423,19 @@ where /// Relayouts and returns a new [`UserInterface`] using the provided /// bounds. pub fn relayout(self, bounds: Size, renderer: &mut Renderer) -> Self { - Self::build( - self.root, - bounds, - Cache { - base: self.base, - overlay: self.overlay, - bounds: self.bounds, - }, - renderer, - ) + Self::build(self.root, bounds, Cache, renderer) } /// Extract the [`Cache`] of the [`UserInterface`], consuming it in the /// process. pub fn into_cache(self) -> Cache { - Cache { - base: self.base, - overlay: self.overlay, - bounds: self.bounds, - } - } - - fn overlay_layer( - cache: Option, - bounds: Size, - overlay: &mut overlay::Element<'_, Message, Renderer>, - renderer: &Renderer, - ) -> Layer { - let new_hash = { - let hasher = &mut crate::Hasher::default(); - overlay.hash_layout(hasher); - - hasher.finish() - }; - - let layout = match cache { - Some(Layer { hash, layout }) if new_hash == hash => layout, - _ => overlay.layout(renderer, bounds), - }; - - Layer { - layout, - hash: new_hash, - } + Cache } } -#[derive(Debug, Clone)] -struct Layer { - layout: layout::Node, - hash: u64, -} - /// Reusable data of a specific [`UserInterface`]. #[derive(Debug, Clone)] -pub struct Cache { - base: Layer, - overlay: Option, - bounds: Size, -} +pub struct Cache; impl Cache { /// Creates an empty [`Cache`]. @@ -554,14 +443,7 @@ impl Cache { /// You should use this to initialize a [`Cache`] before building your first /// [`UserInterface`]. pub fn new() -> Cache { - Cache { - base: Layer { - layout: layout::Node::new(Size::new(0.0, 0.0)), - hash: 0, - }, - overlay: None, - bounds: Size::ZERO, - } + Cache } } diff --git a/native/src/widget.rs b/native/src/widget.rs index acd2e580..aacdc3d9 100644 --- a/native/src/widget.rs +++ b/native/src/widget.rs @@ -75,7 +75,7 @@ use crate::layout; use crate::mouse; use crate::overlay; use crate::renderer; -use crate::{Clipboard, Hasher, Layout, Length, Point, Rectangle, Shell}; +use crate::{Clipboard, Layout, Length, Point, Rectangle, Shell}; /// A component that displays information and allows interaction. /// @@ -131,19 +131,6 @@ where viewport: &Rectangle, ); - /// Computes the _layout_ hash of the [`Widget`]. - /// - /// The produced hash is used by the runtime to decide if the [`Layout`] - /// needs to be recomputed between frames. Therefore, to ensure maximum - /// efficiency, the hash should only be affected by the properties of the - /// [`Widget`] that can affect layouting. - /// - /// For example, the [`Text`] widget does not hash its color property, as - /// its value cannot affect the overall [`Layout`] of the user interface. - /// - /// [`Text`]: crate::widget::Text - fn hash_layout(&self, state: &mut Hasher); - /// Processes a runtime [`Event`]. /// /// It receives: diff --git a/native/src/widget/button.rs b/native/src/widget/button.rs index b4a3adc3..57fdd7d4 100644 --- a/native/src/widget/button.rs +++ b/native/src/widget/button.rs @@ -8,12 +8,10 @@ use crate::overlay; use crate::renderer; use crate::touch; use crate::{ - Background, Clipboard, Color, Element, Hasher, Layout, Length, Padding, - Point, Rectangle, Shell, Vector, Widget, + Background, Clipboard, Color, Element, Layout, Length, Padding, Point, + Rectangle, Shell, Vector, Widget, }; -use std::hash::Hash; - pub use iced_style::button::{Style, StyleSheet}; /// A generic widget that produces a message when pressed. @@ -333,14 +331,6 @@ where ); } - fn hash_layout(&self, state: &mut Hasher) { - struct Marker; - std::any::TypeId::of::().hash(state); - - self.width.hash(state); - self.content.hash_layout(state); - } - fn overlay( &mut self, layout: Layout<'_>, diff --git a/native/src/widget/checkbox.rs b/native/src/widget/checkbox.rs index fff65a40..15cbf93a 100644 --- a/native/src/widget/checkbox.rs +++ b/native/src/widget/checkbox.rs @@ -1,6 +1,4 @@ //! Show toggle controls using checkboxes. -use std::hash::Hash; - use crate::alignment; use crate::event::{self, Event}; use crate::layout; @@ -10,8 +8,8 @@ use crate::text; use crate::touch; use crate::widget::{self, Row, Text}; use crate::{ - Alignment, Clipboard, Element, Hasher, Layout, Length, Point, Rectangle, - Shell, Widget, + Alignment, Clipboard, Element, Layout, Length, Point, Rectangle, Shell, + Widget, }; pub use iced_style::checkbox::{Style, StyleSheet}; @@ -262,13 +260,6 @@ where ); } } - - fn hash_layout(&self, state: &mut Hasher) { - struct Marker; - std::any::TypeId::of::().hash(state); - - self.label.hash(state); - } } impl<'a, Message, Renderer> From> diff --git a/native/src/widget/column.rs b/native/src/widget/column.rs index 66ed5e23..f161d1f2 100644 --- a/native/src/widget/column.rs +++ b/native/src/widget/column.rs @@ -1,14 +1,12 @@ //! Distribute content vertically. -use std::hash::Hash; - use crate::event::{self, Event}; use crate::layout; use crate::mouse; use crate::overlay; use crate::renderer; use crate::{ - Alignment, Clipboard, Element, Hasher, Layout, Length, Padding, Point, - Rectangle, Shell, Widget, + Alignment, Clipboard, Element, Layout, Length, Padding, Point, Rectangle, + Shell, Widget, }; use std::u32; @@ -199,23 +197,6 @@ where } } - fn hash_layout(&self, state: &mut Hasher) { - struct Marker; - std::any::TypeId::of::().hash(state); - - self.width.hash(state); - self.height.hash(state); - self.max_width.hash(state); - self.max_height.hash(state); - self.align_items.hash(state); - self.spacing.hash(state); - self.padding.hash(state); - - for child in &self.children { - child.widget.hash_layout(state); - } - } - fn overlay( &mut self, layout: Layout<'_>, diff --git a/native/src/widget/container.rs b/native/src/widget/container.rs index 4444732a..ca85a425 100644 --- a/native/src/widget/container.rs +++ b/native/src/widget/container.rs @@ -1,6 +1,4 @@ //! Decorate content and apply alignment. -use std::hash::Hash; - use crate::alignment::{self, Alignment}; use crate::event::{self, Event}; use crate::layout; @@ -8,8 +6,8 @@ use crate::mouse; use crate::overlay; use crate::renderer; use crate::{ - Background, Clipboard, Color, Element, Hasher, Layout, Length, Padding, - Point, Rectangle, Shell, Widget, + Background, Clipboard, Color, Element, Layout, Length, Padding, Point, + Rectangle, Shell, Widget, }; use std::u32; @@ -219,21 +217,6 @@ where ); } - fn hash_layout(&self, state: &mut Hasher) { - struct Marker; - std::any::TypeId::of::().hash(state); - - self.padding.hash(state); - self.width.hash(state); - self.height.hash(state); - self.max_width.hash(state); - self.max_height.hash(state); - self.horizontal_alignment.hash(state); - self.vertical_alignment.hash(state); - - self.content.hash_layout(state); - } - fn overlay( &mut self, layout: Layout<'_>, diff --git a/native/src/widget/image.rs b/native/src/widget/image.rs index 83c24ee5..de0ffbc0 100644 --- a/native/src/widget/image.rs +++ b/native/src/widget/image.rs @@ -6,8 +6,7 @@ use crate::image; use crate::layout; use crate::renderer; use crate::{ - ContentFit, Element, Hasher, Layout, Length, Point, Rectangle, Size, - Vector, Widget, + ContentFit, Element, Layout, Length, Point, Rectangle, Size, Vector, Widget, }; use std::hash::Hash; @@ -149,16 +148,6 @@ where render(renderer) } } - - fn hash_layout(&self, state: &mut Hasher) { - struct Marker; - std::any::TypeId::of::().hash(state); - - self.handle.hash(state); - self.width.hash(state); - self.height.hash(state); - self.content_fit.hash(state); - } } impl<'a, Message, Renderer, Handle> From> diff --git a/native/src/widget/image/viewer.rs b/native/src/widget/image/viewer.rs index 486d5fa5..840b88e5 100644 --- a/native/src/widget/image/viewer.rs +++ b/native/src/widget/image/viewer.rs @@ -5,8 +5,8 @@ use crate::layout; use crate::mouse; use crate::renderer; use crate::{ - Clipboard, Element, Hasher, Layout, Length, Point, Rectangle, Shell, Size, - Vector, Widget, + Clipboard, Element, Layout, Length, Point, Rectangle, Shell, Size, Vector, + Widget, }; use std::hash::Hash; @@ -335,17 +335,6 @@ where }); }); } - - fn hash_layout(&self, state: &mut Hasher) { - struct Marker; - std::any::TypeId::of::().hash(state); - - self.width.hash(state); - self.height.hash(state); - self.padding.hash(state); - - self.handle.hash(state); - } } /// The local state of a [`Viewer`]. diff --git a/native/src/widget/pane_grid.rs b/native/src/widget/pane_grid.rs index 5f293fa6..8ad63cf1 100644 --- a/native/src/widget/pane_grid.rs +++ b/native/src/widget/pane_grid.rs @@ -34,8 +34,8 @@ use crate::overlay; use crate::renderer; use crate::touch; use crate::{ - Clipboard, Color, Element, Hasher, Layout, Length, Point, Rectangle, Shell, - Size, Vector, Widget, + Clipboard, Color, Element, Layout, Length, Point, Rectangle, Shell, Size, + Vector, Widget, }; pub use iced_style::pane_grid::{Line, StyleSheet}; @@ -666,21 +666,6 @@ where } } - fn hash_layout(&self, state: &mut Hasher) { - use std::hash::Hash; - - struct Marker; - std::any::TypeId::of::().hash(state); - - self.width.hash(state); - self.height.hash(state); - self.state.hash_layout(state); - - for (_, element) in &self.elements { - element.hash_layout(state); - } - } - fn overlay( &mut self, layout: Layout<'_>, diff --git a/native/src/widget/pane_grid/content.rs b/native/src/widget/pane_grid/content.rs index 6d12aa2d..8b0e8d2a 100644 --- a/native/src/widget/pane_grid/content.rs +++ b/native/src/widget/pane_grid/content.rs @@ -5,9 +5,7 @@ use crate::overlay; use crate::renderer; use crate::widget::container; use crate::widget::pane_grid::TitleBar; -use crate::{ - Clipboard, Element, Hasher, Layout, Point, Rectangle, Shell, Size, -}; +use crate::{Clipboard, Element, Layout, Point, Rectangle, Shell, Size}; /// The content of a [`Pane`]. /// @@ -236,14 +234,6 @@ where .max(title_bar_interaction) } - pub(crate) fn hash_layout(&self, state: &mut Hasher) { - if let Some(title_bar) = &self.title_bar { - title_bar.hash_layout(state); - } - - self.body.hash_layout(state); - } - pub(crate) fn overlay( &mut self, layout: Layout<'_>, diff --git a/native/src/widget/pane_grid/state.rs b/native/src/widget/pane_grid/state.rs index bcc724a8..feea0dec 100644 --- a/native/src/widget/pane_grid/state.rs +++ b/native/src/widget/pane_grid/state.rs @@ -1,7 +1,7 @@ use crate::widget::pane_grid::{ Axis, Configuration, Direction, Node, Pane, Split, }; -use crate::{Hasher, Point, Rectangle, Size}; +use crate::{Point, Rectangle, Size}; use std::collections::{BTreeMap, HashMap}; @@ -292,10 +292,4 @@ impl Internal { pub fn idle(&mut self) { self.action = Action::Idle; } - - pub fn hash_layout(&self, hasher: &mut Hasher) { - use std::hash::Hash; - - self.layout.hash(hasher); - } } diff --git a/native/src/widget/pane_grid/title_bar.rs b/native/src/widget/pane_grid/title_bar.rs index ea9ebfc4..d56972ec 100644 --- a/native/src/widget/pane_grid/title_bar.rs +++ b/native/src/widget/pane_grid/title_bar.rs @@ -5,7 +5,7 @@ use crate::overlay; use crate::renderer; use crate::widget::container; use crate::{ - Clipboard, Element, Hasher, Layout, Padding, Point, Rectangle, Shell, Size, + Clipboard, Element, Layout, Padding, Point, Rectangle, Shell, Size, }; /// The title bar of a [`Pane`]. @@ -157,17 +157,6 @@ where } } - pub(crate) fn hash_layout(&self, hasher: &mut Hasher) { - use std::hash::Hash; - - self.content.hash_layout(hasher); - self.padding.hash(hasher); - - if let Some(controls) = &self.controls { - controls.hash_layout(hasher); - } - } - pub(crate) fn layout( &self, renderer: &Renderer, diff --git a/native/src/widget/pick_list.rs b/native/src/widget/pick_list.rs index a200fb13..3be6c20c 100644 --- a/native/src/widget/pick_list.rs +++ b/native/src/widget/pick_list.rs @@ -10,8 +10,8 @@ use crate::renderer; use crate::text::{self, Text}; use crate::touch; use crate::{ - Clipboard, Element, Hasher, Layout, Length, Padding, Point, Rectangle, - Shell, Size, Widget, + Clipboard, Element, Layout, Length, Padding, Point, Rectangle, Shell, Size, + Widget, }; use std::borrow::Cow; @@ -220,24 +220,6 @@ where layout::Node::new(size) } - fn hash_layout(&self, state: &mut Hasher) { - use std::hash::Hash as _; - - match self.width { - Length::Shrink => { - self.placeholder.hash(state); - - self.options - .iter() - .map(ToString::to_string) - .for_each(|label| label.hash(state)); - } - _ => { - self.width.hash(state); - } - } - } - fn on_event( &mut self, event: Event, diff --git a/native/src/widget/progress_bar.rs b/native/src/widget/progress_bar.rs index 69eb8c09..c26c38fa 100644 --- a/native/src/widget/progress_bar.rs +++ b/native/src/widget/progress_bar.rs @@ -1,11 +1,9 @@ //! Provide progress feedback to your users. use crate::layout; use crate::renderer; -use crate::{ - Color, Element, Hasher, Layout, Length, Point, Rectangle, Size, Widget, -}; +use crate::{Color, Element, Layout, Length, Point, Rectangle, Size, Widget}; -use std::{hash::Hash, ops::RangeInclusive}; +use std::ops::RangeInclusive; pub use iced_style::progress_bar::{Style, StyleSheet}; @@ -141,14 +139,6 @@ where ); } } - - fn hash_layout(&self, state: &mut Hasher) { - struct Marker; - std::any::TypeId::of::().hash(state); - - self.width.hash(state); - self.height.hash(state); - } } impl<'a, Message, Renderer> From> diff --git a/native/src/widget/radio.rs b/native/src/widget/radio.rs index c4992764..fed2925b 100644 --- a/native/src/widget/radio.rs +++ b/native/src/widget/radio.rs @@ -1,6 +1,4 @@ //! Create choices using radio buttons. -use std::hash::Hash; - use crate::alignment; use crate::event::{self, Event}; use crate::layout; @@ -10,8 +8,8 @@ use crate::text; use crate::touch; use crate::widget::{self, Row, Text}; use crate::{ - Alignment, Clipboard, Color, Element, Hasher, Layout, Length, Point, - Rectangle, Shell, Widget, + Alignment, Clipboard, Color, Element, Layout, Length, Point, Rectangle, + Shell, Widget, }; pub use iced_style::radio::{Style, StyleSheet}; @@ -280,13 +278,6 @@ where ); } } - - fn hash_layout(&self, state: &mut Hasher) { - struct Marker; - std::any::TypeId::of::().hash(state); - - self.label.hash(state); - } } impl<'a, Message, Renderer> From> diff --git a/native/src/widget/row.rs b/native/src/widget/row.rs index c423d31f..e34befb2 100644 --- a/native/src/widget/row.rs +++ b/native/src/widget/row.rs @@ -5,11 +5,10 @@ use crate::mouse; use crate::overlay; use crate::renderer; use crate::{ - Alignment, Clipboard, Element, Hasher, Layout, Length, Padding, Point, - Rectangle, Shell, Widget, + Alignment, Clipboard, Element, Layout, Length, Padding, Point, Rectangle, + Shell, Widget, }; -use std::hash::Hash; use std::u32; /// A container that distributes its contents horizontally. @@ -198,23 +197,6 @@ where } } - fn hash_layout(&self, state: &mut Hasher) { - struct Marker; - std::any::TypeId::of::().hash(state); - - self.width.hash(state); - self.height.hash(state); - self.max_width.hash(state); - self.max_height.hash(state); - self.align_items.hash(state); - self.spacing.hash(state); - self.padding.hash(state); - - for child in &self.children { - child.widget.hash_layout(state); - } - } - fn overlay( &mut self, layout: Layout<'_>, diff --git a/native/src/widget/rule.rs b/native/src/widget/rule.rs index 7c8c5dbc..b0cc3768 100644 --- a/native/src/widget/rule.rs +++ b/native/src/widget/rule.rs @@ -1,11 +1,7 @@ //! Display a horizontal or vertical rule for dividing content. use crate::layout; use crate::renderer; -use crate::{ - Color, Element, Hasher, Layout, Length, Point, Rectangle, Size, Widget, -}; - -use std::hash::Hash; +use crate::{Color, Element, Layout, Length, Point, Rectangle, Size, Widget}; pub use iced_style::rule::{FillMode, Style, StyleSheet}; @@ -122,14 +118,6 @@ where style.color, ); } - - fn hash_layout(&self, state: &mut Hasher) { - struct Marker; - std::any::TypeId::of::().hash(state); - - self.width.hash(state); - self.height.hash(state); - } } impl<'a, Message, Renderer> From> for Element<'a, Message, Renderer> diff --git a/native/src/widget/scrollable.rs b/native/src/widget/scrollable.rs index 4b005c6b..ce734ad8 100644 --- a/native/src/widget/scrollable.rs +++ b/native/src/widget/scrollable.rs @@ -7,11 +7,11 @@ use crate::renderer; use crate::touch; use crate::widget::Column; use crate::{ - Alignment, Background, Clipboard, Color, Element, Hasher, Layout, Length, - Padding, Point, Rectangle, Shell, Size, Vector, Widget, + Alignment, Background, Clipboard, Color, Element, Layout, Length, Padding, + Point, Rectangle, Shell, Size, Vector, Widget, }; -use std::{f32, hash::Hash, u32}; +use std::{f32, u32}; pub use iced_style::scrollable::StyleSheet; @@ -570,16 +570,6 @@ where } } - fn hash_layout(&self, state: &mut Hasher) { - struct Marker; - std::any::TypeId::of::().hash(state); - - self.height.hash(state); - self.max_height.hash(state); - - self.content.hash_layout(state) - } - fn overlay( &mut self, layout: Layout<'_>, diff --git a/native/src/widget/slider.rs b/native/src/widget/slider.rs index 917bfc14..289f75f5 100644 --- a/native/src/widget/slider.rs +++ b/native/src/widget/slider.rs @@ -7,11 +7,10 @@ use crate::mouse; use crate::renderer; use crate::touch; use crate::{ - Background, Clipboard, Color, Element, Hasher, Layout, Length, Point, - Rectangle, Shell, Size, Widget, + Background, Clipboard, Color, Element, Layout, Length, Point, Rectangle, + Shell, Size, Widget, }; -use std::hash::Hash; use std::ops::RangeInclusive; pub use iced_style::slider::{Handle, HandleShape, Style, StyleSheet}; @@ -374,13 +373,6 @@ where mouse::Interaction::default() } } - - fn hash_layout(&self, state: &mut Hasher) { - struct Marker; - std::any::TypeId::of::().hash(state); - - self.width.hash(state); - } } impl<'a, T, Message, Renderer> From> diff --git a/native/src/widget/space.rs b/native/src/widget/space.rs index 3373f3b7..4135d1b8 100644 --- a/native/src/widget/space.rs +++ b/native/src/widget/space.rs @@ -1,9 +1,7 @@ //! Distribute content vertically. use crate::layout; use crate::renderer; -use crate::{Element, Hasher, Layout, Length, Point, Rectangle, Size, Widget}; - -use std::hash::Hash; +use crate::{Element, Layout, Length, Point, Rectangle, Size, Widget}; /// An amount of empty space. /// @@ -68,13 +66,6 @@ where _viewport: &Rectangle, ) { } - - fn hash_layout(&self, state: &mut Hasher) { - std::any::TypeId::of::().hash(state); - - self.width.hash(state); - self.height.hash(state); - } } impl<'a, Message, Renderer> From for Element<'a, Message, Renderer> diff --git a/native/src/widget/svg.rs b/native/src/widget/svg.rs index 22aac331..008ab356 100644 --- a/native/src/widget/svg.rs +++ b/native/src/widget/svg.rs @@ -3,11 +3,9 @@ use crate::layout; use crate::renderer; use crate::svg::{self, Handle}; use crate::{ - ContentFit, Element, Hasher, Layout, Length, Point, Rectangle, Size, - Vector, Widget, + ContentFit, Element, Layout, Length, Point, Rectangle, Size, Vector, Widget, }; -use std::hash::Hash; use std::path::PathBuf; /// A vector graphics image. @@ -146,15 +144,6 @@ where render(renderer) } } - - fn hash_layout(&self, state: &mut Hasher) { - std::any::TypeId::of::().hash(state); - - self.handle.hash(state); - self.width.hash(state); - self.height.hash(state); - self.content_fit.hash(state); - } } impl<'a, Message, Renderer> From for Element<'a, Message, Renderer> diff --git a/native/src/widget/text.rs b/native/src/widget/text.rs index f0b29d15..6f00c9c8 100644 --- a/native/src/widget/text.rs +++ b/native/src/widget/text.rs @@ -3,11 +3,7 @@ use crate::alignment; use crate::layout; use crate::renderer; use crate::text; -use crate::{ - Color, Element, Hasher, Layout, Length, Point, Rectangle, Size, Widget, -}; - -use std::hash::Hash; +use crate::{Color, Element, Layout, Length, Point, Rectangle, Size, Widget}; /// A paragraph of text. /// @@ -151,16 +147,6 @@ where self.vertical_alignment, ); } - - fn hash_layout(&self, state: &mut Hasher) { - struct Marker; - std::any::TypeId::of::().hash(state); - - self.content.hash(state); - self.size.hash(state); - self.width.hash(state); - self.height.hash(state); - } } /// Draws text using the same logic as the [`Text`] widget. diff --git a/native/src/widget/text_input.rs b/native/src/widget/text_input.rs index 03adeb12..e30e2343 100644 --- a/native/src/widget/text_input.rs +++ b/native/src/widget/text_input.rs @@ -20,8 +20,8 @@ use crate::renderer; use crate::text::{self, Text}; use crate::touch; use crate::{ - Clipboard, Color, Element, Hasher, Layout, Length, Padding, Point, - Rectangle, Shell, Size, Vector, Widget, + Clipboard, Color, Element, Layout, Length, Padding, Point, Rectangle, + Shell, Size, Vector, Widget, }; use std::u32; @@ -783,17 +783,6 @@ where ) { self.draw(renderer, layout, cursor_position, None) } - - fn hash_layout(&self, state: &mut Hasher) { - use std::{any::TypeId, hash::Hash}; - struct Marker; - TypeId::of::().hash(state); - - self.width.hash(state); - self.max_width.hash(state); - self.padding.hash(state); - self.size.hash(state); - } } impl<'a, Message, Renderer> From> diff --git a/native/src/widget/toggler.rs b/native/src/widget/toggler.rs index 002e0a4f..48237edb 100644 --- a/native/src/widget/toggler.rs +++ b/native/src/widget/toggler.rs @@ -1,5 +1,4 @@ //! Show toggle controls using togglers. -use std::hash::Hash; use crate::alignment; use crate::event; @@ -9,8 +8,8 @@ use crate::renderer; use crate::text; use crate::widget::{Row, Text}; use crate::{ - Alignment, Clipboard, Element, Event, Hasher, Layout, Length, Point, - Rectangle, Shell, Widget, + Alignment, Clipboard, Element, Event, Layout, Length, Point, Rectangle, + Shell, Widget, }; pub use iced_style::toggler::{Style, StyleSheet}; @@ -295,13 +294,6 @@ where style.foreground, ); } - - fn hash_layout(&self, state: &mut Hasher) { - struct Marker; - std::any::TypeId::of::().hash(state); - - self.label.hash(state) - } } impl<'a, Message, Renderer> From> diff --git a/native/src/widget/tooltip.rs b/native/src/widget/tooltip.rs index f6630864..7989c768 100644 --- a/native/src/widget/tooltip.rs +++ b/native/src/widget/tooltip.rs @@ -1,8 +1,4 @@ //! Display a widget over another. -use std::hash::Hash; - -use iced_core::Rectangle; - use crate::event; use crate::layout; use crate::mouse; @@ -11,8 +7,8 @@ use crate::text; use crate::widget::container; use crate::widget::text::Text; use crate::{ - Clipboard, Element, Event, Hasher, Layout, Length, Padding, Point, Shell, - Size, Vector, Widget, + Clipboard, Element, Event, Layout, Length, Padding, Point, Rectangle, + Shell, Size, Vector, Widget, }; /// An element to display a widget over another. @@ -268,13 +264,6 @@ where }); } } - - fn hash_layout(&self, state: &mut Hasher) { - struct Marker; - std::any::TypeId::of::().hash(state); - - self.content.hash_layout(state); - } } impl<'a, Message, Renderer> From> -- cgit