From c59149e63c9fe297b48c0c57d49c1b43b13a7a6b Mon Sep 17 00:00:00 2001
From: ickshonpe <david.curthoys@googlemail.com>
Date: Thu, 30 Mar 2023 15:17:54 +0100
Subject: [PATCH 01/20] changes: * Removed function `update_changed` from
 `flex_node_system` * Added a `Without<Calculated>` query filter so the two
 changed node queries in `flex_node_system` are mutually exclusive. * Moved
 the leaf node update loop into the else block of the update-all if statement.

---
 crates/bevy_ui/src/flex/mod.rs | 44 ++++++++++++++++------------------
 1 file changed, 21 insertions(+), 23 deletions(-)

diff --git a/crates/bevy_ui/src/flex/mod.rs b/crates/bevy_ui/src/flex/mod.rs
index 62ab50196e5ee..5ccd2cd777f03 100644
--- a/crates/bevy_ui/src/flex/mod.rs
+++ b/crates/bevy_ui/src/flex/mod.rs
@@ -5,7 +5,7 @@ use bevy_ecs::{
     change_detection::DetectChanges,
     entity::Entity,
     event::EventReader,
-    query::{Changed, ReadOnlyWorldQuery, With, Without},
+    query::{Changed, Or, ReadOnlyWorldQuery, With, Without},
     removal_detection::RemovedComponents,
     system::{Query, Res, ResMut, Resource},
 };
@@ -250,11 +250,14 @@ pub fn flex_node_system(
     mut resize_events: EventReader<bevy_window::WindowResized>,
     mut flex_surface: ResMut<FlexSurface>,
     root_node_query: Query<Entity, (With<Node>, Without<Parent>)>,
-    node_query: Query<(Entity, &Style, Option<&CalculatedSize>), (With<Node>, Changed<Style>)>,
     full_node_query: Query<(Entity, &Style, Option<&CalculatedSize>), With<Node>>,
+    changed_style_query: Query<
+        (Entity, &Style),
+        (With<Node>, Without<CalculatedSize>, Changed<Style>),
+    >,
     changed_size_query: Query<
         (Entity, &Style, &CalculatedSize),
-        (With<Node>, Changed<CalculatedSize>),
+        (With<Node>, Or<(Changed<CalculatedSize>, Changed<Style>)>),
     >,
     children_query: Query<(Entity, &Children), (With<Node>, Changed<Children>)>,
     mut removed_children: RemovedComponents<Children>,
@@ -288,33 +291,28 @@ pub fn flex_node_system(
 
     let scale_factor = logical_to_physical_factor * ui_scale.scale;
 
-    let viewport_values = LayoutContext::new(scale_factor, physical_size);
+    let layout_context = LayoutContext::new(scale_factor, physical_size);
 
-    fn update_changed<F: ReadOnlyWorldQuery>(
-        flex_surface: &mut FlexSurface,
-        viewport_values: &LayoutContext,
-        query: Query<(Entity, &Style, Option<&CalculatedSize>), F>,
-    ) {
-        // update changed nodes
-        for (entity, style, calculated_size) in &query {
-            // TODO: remove node from old hierarchy if its root has changed
+    if !scale_factor_events.is_empty() || ui_scale.is_changed() || resized {
+        scale_factor_events.clear();
+        // update all nodes
+        for (entity, style, calculated_size) in &full_node_query {
             if let Some(calculated_size) = calculated_size {
-                flex_surface.upsert_leaf(entity, style, *calculated_size, viewport_values);
+                flex_surface.upsert_leaf(entity, style, *calculated_size, &layout_context);
             } else {
-                flex_surface.upsert_node(entity, style, viewport_values);
+                flex_surface.upsert_node(entity, style, &layout_context);
             }
         }
-    }
-
-    if !scale_factor_events.is_empty() || ui_scale.is_changed() || resized {
-        scale_factor_events.clear();
-        update_changed(&mut flex_surface, &viewport_values, full_node_query);
     } else {
-        update_changed(&mut flex_surface, &viewport_values, node_query);
-    }
+        // update changed nodes without a calculated size
+        for (entity, style) in changed_style_query.iter() {
+            flex_surface.upsert_node(entity, style, &layout_context);
+        }
 
-    for (entity, style, calculated_size) in &changed_size_query {
-        flex_surface.upsert_leaf(entity, style, *calculated_size, &viewport_values);
+        // update changed nodes with a calculated size
+        for (entity, style, calculated_size) in changed_size_query.iter() {
+            flex_surface.upsert_leaf(entity, style, *calculated_size, &layout_context);
+        }
     }
 
     // clean up removed nodes

From 015dd748bf6f1262ae7eba9a21eef20d64c0ee51 Mon Sep 17 00:00:00 2001
From: ickshonpe <david.curthoys@googlemail.com>
Date: Thu, 30 Mar 2023 15:53:12 +0100
Subject: [PATCH 02/20] fixed unused import

---
 crates/bevy_ui/src/flex/mod.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/crates/bevy_ui/src/flex/mod.rs b/crates/bevy_ui/src/flex/mod.rs
index 5ccd2cd777f03..9bbe31cff7169 100644
--- a/crates/bevy_ui/src/flex/mod.rs
+++ b/crates/bevy_ui/src/flex/mod.rs
@@ -5,7 +5,7 @@ use bevy_ecs::{
     change_detection::DetectChanges,
     entity::Entity,
     event::EventReader,
-    query::{Changed, Or, ReadOnlyWorldQuery, With, Without},
+    query::{Changed, Or, With, Without},
     removal_detection::RemovedComponents,
     system::{Query, Res, ResMut, Resource},
 };

From 3e1fbfe9654524763fc4484c659e767d7cb46299 Mon Sep 17 00:00:00 2001
From: ickshonpe <david.curthoys@googlemail.com>
Date: Sun, 16 Apr 2023 12:54:47 +0100
Subject: [PATCH 03/20] changes: * Replaced `upsert_leaf` with a function
 `update_measure` that only updates a nodes `MeasureFunc`. * `MeasureFunc`s
 are only updated when the `CalculatedSize` changes and not when the layout
 changes. * Scale factor is no longer applied to the size values passed to the
 measure func. * Remove the `CalculatedSize` scaling in `text_system`.

---
 crates/bevy_ui/src/flex/mod.rs    | 59 +++++++++++--------------------
 crates/bevy_ui/src/widget/text.rs |  4 +--
 2 files changed, 22 insertions(+), 41 deletions(-)

diff --git a/crates/bevy_ui/src/flex/mod.rs b/crates/bevy_ui/src/flex/mod.rs
index 9bbe31cff7169..e0b94e2621770 100644
--- a/crates/bevy_ui/src/flex/mod.rs
+++ b/crates/bevy_ui/src/flex/mod.rs
@@ -5,9 +5,9 @@ use bevy_ecs::{
     change_detection::DetectChanges,
     entity::Entity,
     event::EventReader,
-    query::{Changed, Or, With, Without},
+    query::{Changed, With, Without},
     removal_detection::RemovedComponents,
-    system::{Query, Res, ResMut, Resource},
+    system::{Query, Res, ResMut, Resource}, world::Ref,
 };
 use bevy_hierarchy::{Children, Parent};
 use bevy_log::warn;
@@ -93,21 +93,16 @@ impl FlexSurface {
         }
     }
 
-    pub fn upsert_leaf(
+    pub fn update_measure(
         &mut self,
         entity: Entity,
-        style: &Style,
         calculated_size: CalculatedSize,
-        context: &LayoutContext,
     ) {
-        let taffy = &mut self.taffy;
-        let taffy_style = convert::from_style(context, style);
-        let scale_factor = context.scale_factor;
         let measure = taffy::node::MeasureFunc::Boxed(Box::new(
             move |constraints: Size<Option<f32>>, _available: Size<AvailableSpace>| {
-                let mut size = Size {
-                    width: (scale_factor * calculated_size.size.x as f64) as f32,
-                    height: (scale_factor * calculated_size.size.y as f64) as f32,
+                let mut size = Size { 
+                    width: calculated_size.size.x,
+                    height: calculated_size.size.y
                 };
                 match (constraints.width, constraints.height) {
                     (None, None) => {}
@@ -131,13 +126,8 @@ impl FlexSurface {
                 size
             },
         ));
-        if let Some(taffy_node) = self.entity_to_taffy.get(&entity) {
-            self.taffy.set_style(*taffy_node, taffy_style).unwrap();
-            self.taffy.set_measure(*taffy_node, Some(measure)).unwrap();
-        } else {
-            let taffy_node = taffy.new_leaf_with_measure(taffy_style, measure).unwrap();
-            self.entity_to_taffy.insert(entity, taffy_node);
-        }
+        let taffy_node = self.entity_to_taffy.get(&entity).unwrap();
+        self.taffy.set_measure(*taffy_node, Some(measure)).ok();
     }
 
     pub fn update_children(&mut self, entity: Entity, children: &Children) {
@@ -250,15 +240,8 @@ pub fn flex_node_system(
     mut resize_events: EventReader<bevy_window::WindowResized>,
     mut flex_surface: ResMut<FlexSurface>,
     root_node_query: Query<Entity, (With<Node>, Without<Parent>)>,
-    full_node_query: Query<(Entity, &Style, Option<&CalculatedSize>), With<Node>>,
-    changed_style_query: Query<
-        (Entity, &Style),
-        (With<Node>, Without<CalculatedSize>, Changed<Style>),
-    >,
-    changed_size_query: Query<
-        (Entity, &Style, &CalculatedSize),
-        (With<Node>, Or<(Changed<CalculatedSize>, Changed<Style>)>),
-    >,
+    style_query: Query<(Entity, Ref<Style>), With<Node>>,
+    measure_query: Query<(Entity, Ref<CalculatedSize>)>,
     children_query: Query<(Entity, &Children), (With<Node>, Changed<Children>)>,
     mut removed_children: RemovedComponents<Children>,
     mut node_transform_query: Query<(Entity, &mut Node, &mut Transform, Option<&Parent>)>,
@@ -296,22 +279,20 @@ pub fn flex_node_system(
     if !scale_factor_events.is_empty() || ui_scale.is_changed() || resized {
         scale_factor_events.clear();
         // update all nodes
-        for (entity, style, calculated_size) in &full_node_query {
-            if let Some(calculated_size) = calculated_size {
-                flex_surface.upsert_leaf(entity, style, *calculated_size, &layout_context);
-            } else {
-                flex_surface.upsert_node(entity, style, &layout_context);
-            }
+        for (entity, style) in style_query.iter() {
+            flex_surface.upsert_node(entity, &style, &layout_context);
         }
     } else {
-        // update changed nodes without a calculated size
-        for (entity, style) in changed_style_query.iter() {
-            flex_surface.upsert_node(entity, style, &layout_context);
+        for (entity, style) in style_query.iter() {
+            if style.is_changed() {
+                flex_surface.upsert_node(entity, &style, &layout_context);
+            }
         }
+    }
 
-        // update changed nodes with a calculated size
-        for (entity, style, calculated_size) in changed_size_query.iter() {
-            flex_surface.upsert_leaf(entity, style, *calculated_size, &layout_context);
+    for (entity, calculated_size) in measure_query.iter() {
+        if calculated_size.is_changed() {
+            flex_surface.update_measure(entity, *calculated_size);
         }
     }
 
diff --git a/crates/bevy_ui/src/widget/text.rs b/crates/bevy_ui/src/widget/text.rs
index e3404575e8ee3..f5f637f91916a 100644
--- a/crates/bevy_ui/src/widget/text.rs
+++ b/crates/bevy_ui/src/widget/text.rs
@@ -134,8 +134,8 @@ pub fn text_system(
                 }
                 Ok(info) => {
                     calculated_size.size = Vec2::new(
-                        scale_value(info.size.x, inv_scale_factor),
-                        scale_value(info.size.y, inv_scale_factor),
+                        info.size.x,
+                       info.size.y,
                     );
                     match text_layout_info {
                         Some(mut t) => *t = info,

From 3236980bea26cd27f88fdad5cbe071d9ed040cc1 Mon Sep 17 00:00:00 2001
From: ickshonpe <david.curthoys@googlemail.com>
Date: Tue, 18 Apr 2023 13:27:24 +0100
Subject: [PATCH 04/20] cargo fmt

---
 crates/bevy_ui/src/layout/mod.rs  | 11 +++--------
 crates/bevy_ui/src/widget/text.rs |  6 +++---
 2 files changed, 6 insertions(+), 11 deletions(-)

diff --git a/crates/bevy_ui/src/layout/mod.rs b/crates/bevy_ui/src/layout/mod.rs
index 8b0786694d465..b7d916b952e40 100644
--- a/crates/bevy_ui/src/layout/mod.rs
+++ b/crates/bevy_ui/src/layout/mod.rs
@@ -7,7 +7,8 @@ use bevy_ecs::{
     event::EventReader,
     query::{Changed, With, Without},
     removal_detection::RemovedComponents,
-    system::{Query, Res, ResMut, Resource}, world::Ref,
+    system::{Query, Res, ResMut, Resource},
+    world::Ref,
 };
 use bevy_hierarchy::{Children, Parent};
 use bevy_log::warn;
@@ -90,12 +91,7 @@ impl UiSurface {
         }
     }
 
-    pub fn update_measure(
-        &mut self,
-        entity: Entity,
-        calculated_size: &CalculatedSize,
-    ) {
-
+    pub fn update_measure(&mut self, entity: Entity, calculated_size: &CalculatedSize) {
         let measure = calculated_size.measure.dyn_clone();
         let measure_func = taffy::node::MeasureFunc::Boxed(Box::new(
             move |constraints: Size<Option<f32>>, available: Size<AvailableSpace>| {
@@ -270,7 +266,6 @@ pub fn ui_layout_system(
 
     let layout_context = LayoutContext::new(scale_factor, physical_size);
 
-
     if !scale_factor_events.is_empty() || ui_scale.is_changed() || resized {
         scale_factor_events.clear();
         // update all nodes
diff --git a/crates/bevy_ui/src/widget/text.rs b/crates/bevy_ui/src/widget/text.rs
index 958b460957578..4015d0119bbf9 100644
--- a/crates/bevy_ui/src/widget/text.rs
+++ b/crates/bevy_ui/src/widget/text.rs
@@ -208,7 +208,7 @@ pub fn text_system(
                     panic!("Fatal error when processing text: {e}.");
                 }
                 Ok(info) => {
-//<<<<<<< HEAD
+                    //<<<<<<< HEAD
                     // calculated_size.size = Vec2::new(
                     //     info.size.x,
                     //    info.size.y,
@@ -219,9 +219,9 @@ pub fn text_system(
                     //         commands.entity(entity).insert(info);
                     //     }
                     // }
-//=======
+                    //=======
                     *text_layout_info = info;
-//>>>>>>> main
+                    //>>>>>>> main
                 }
             }
         }

From 09687af2dc2d7b74a06ed38011e44c5244ea2778 Mon Sep 17 00:00:00 2001
From: ickshonpe <david.curthoys@googlemail.com>
Date: Tue, 18 Apr 2023 13:54:28 +0100
Subject: [PATCH 05/20] Removed left over commented section from merge

---
 crates/bevy_ui/src/widget/text.rs | 13 -------------
 1 file changed, 13 deletions(-)

diff --git a/crates/bevy_ui/src/widget/text.rs b/crates/bevy_ui/src/widget/text.rs
index 4015d0119bbf9..d8395d4f26f46 100644
--- a/crates/bevy_ui/src/widget/text.rs
+++ b/crates/bevy_ui/src/widget/text.rs
@@ -208,20 +208,7 @@ pub fn text_system(
                     panic!("Fatal error when processing text: {e}.");
                 }
                 Ok(info) => {
-                    //<<<<<<< HEAD
-                    // calculated_size.size = Vec2::new(
-                    //     info.size.x,
-                    //    info.size.y,
-                    // );
-                    // match text_layout_info {
-                    //     Some(mut t) => *t = info,
-                    //     None => {
-                    //         commands.entity(entity).insert(info);
-                    //     }
-                    // }
-                    //=======
                     *text_layout_info = info;
-                    //>>>>>>> main
                 }
             }
         }

From 38931e46d7f2619daff53295957f47f2acdf3ab0 Mon Sep 17 00:00:00 2001
From: ickshonpe <david.curthoys@googlemail.com>
Date: Tue, 18 Apr 2023 13:55:29 +0100
Subject: [PATCH 06/20] renamed `CalculatedSize` to `ContentSize`

---
 crates/bevy_ui/src/layout/mod.rs   | 8 ++++----
 crates/bevy_ui/src/lib.rs          | 2 +-
 crates/bevy_ui/src/measurement.rs  | 8 ++++----
 crates/bevy_ui/src/node_bundles.rs | 6 +++---
 crates/bevy_ui/src/widget/image.rs | 6 +++---
 crates/bevy_ui/src/widget/text.rs  | 4 ++--
 6 files changed, 17 insertions(+), 17 deletions(-)

diff --git a/crates/bevy_ui/src/layout/mod.rs b/crates/bevy_ui/src/layout/mod.rs
index b7d916b952e40..ddf3e1a341cae 100644
--- a/crates/bevy_ui/src/layout/mod.rs
+++ b/crates/bevy_ui/src/layout/mod.rs
@@ -1,6 +1,6 @@
 mod convert;
 
-use crate::{CalculatedSize, Node, Style, UiScale};
+use crate::{ContentSize, Node, Style, UiScale};
 use bevy_ecs::{
     change_detection::DetectChanges,
     entity::Entity,
@@ -91,7 +91,7 @@ impl UiSurface {
         }
     }
 
-    pub fn update_measure(&mut self, entity: Entity, calculated_size: &CalculatedSize) {
+    pub fn update_measure(&mut self, entity: Entity, calculated_size: &ContentSize) {
         let measure = calculated_size.measure.dyn_clone();
         let measure_func = taffy::node::MeasureFunc::Boxed(Box::new(
             move |constraints: Size<Option<f32>>, available: Size<AvailableSpace>| {
@@ -230,10 +230,10 @@ pub fn ui_layout_system(
     mut ui_surface: ResMut<UiSurface>,
     root_node_query: Query<Entity, (With<Node>, Without<Parent>)>,
     style_query: Query<(Entity, Ref<Style>), With<Node>>,
-    measure_query: Query<(Entity, Ref<CalculatedSize>)>,
+    measure_query: Query<(Entity, Ref<ContentSize>)>,
     children_query: Query<(Entity, &Children), (With<Node>, Changed<Children>)>,
     mut removed_children: RemovedComponents<Children>,
-    mut removed_calculated_sizes: RemovedComponents<CalculatedSize>,
+    mut removed_calculated_sizes: RemovedComponents<ContentSize>,
     mut node_transform_query: Query<(Entity, &mut Node, &mut Transform, Option<&Parent>)>,
     mut removed_nodes: RemovedComponents<Node>,
 ) {
diff --git a/crates/bevy_ui/src/lib.rs b/crates/bevy_ui/src/lib.rs
index 7d29d859d18d7..05164fac4fee9 100644
--- a/crates/bevy_ui/src/lib.rs
+++ b/crates/bevy_ui/src/lib.rs
@@ -87,7 +87,7 @@ impl Plugin for UiPlugin {
             .register_type::<AlignContent>()
             .register_type::<AlignItems>()
             .register_type::<AlignSelf>()
-            .register_type::<CalculatedSize>()
+            .register_type::<ContentSize>()
             .register_type::<Direction>()
             .register_type::<Display>()
             .register_type::<FlexDirection>()
diff --git a/crates/bevy_ui/src/measurement.rs b/crates/bevy_ui/src/measurement.rs
index 1fffffeacbe36..13b9e204b692c 100644
--- a/crates/bevy_ui/src/measurement.rs
+++ b/crates/bevy_ui/src/measurement.rs
@@ -4,7 +4,7 @@ use bevy_reflect::Reflect;
 use std::fmt::Formatter;
 pub use taffy::style::AvailableSpace;
 
-impl std::fmt::Debug for CalculatedSize {
+impl std::fmt::Debug for ContentSize {
     fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
         f.debug_struct("CalculatedSize").finish()
     }
@@ -52,14 +52,14 @@ impl Measure for FixedMeasure {
 /// A node with a `CalculatedSize` component is a node where its size
 /// is based on its content.
 #[derive(Component, Reflect)]
-pub struct CalculatedSize {
+pub struct ContentSize {
     /// The `Measure` used to compute the intrinsic size
     #[reflect(ignore)]
     pub measure: Box<dyn Measure>,
 }
 
 #[allow(clippy::derivable_impls)]
-impl Default for CalculatedSize {
+impl Default for ContentSize {
     fn default() -> Self {
         Self {
             // Default `FixedMeasure` always returns zero size.
@@ -68,7 +68,7 @@ impl Default for CalculatedSize {
     }
 }
 
-impl Clone for CalculatedSize {
+impl Clone for ContentSize {
     fn clone(&self) -> Self {
         Self {
             measure: self.measure.dyn_clone(),
diff --git a/crates/bevy_ui/src/node_bundles.rs b/crates/bevy_ui/src/node_bundles.rs
index 3b068e557bb2a..df1fd75d104df 100644
--- a/crates/bevy_ui/src/node_bundles.rs
+++ b/crates/bevy_ui/src/node_bundles.rs
@@ -2,7 +2,7 @@
 
 use crate::{
     widget::{Button, UiImageSize},
-    BackgroundColor, CalculatedSize, FocusPolicy, Interaction, Node, Style, UiImage, ZIndex,
+    BackgroundColor, ContentSize, FocusPolicy, Interaction, Node, Style, UiImage, ZIndex,
 };
 use bevy_ecs::bundle::Bundle;
 use bevy_render::{
@@ -74,7 +74,7 @@ pub struct ImageBundle {
     /// In some cases these styles also affect how the node drawn/painted.
     pub style: Style,
     /// The calculated size based on the given image
-    pub calculated_size: CalculatedSize,
+    pub calculated_size: ContentSize,
     /// The background color, which serves as a "fill" for this node
     ///
     /// Combines with `UiImage` to tint the provided image.
@@ -119,7 +119,7 @@ pub struct TextBundle {
     /// Text layout information
     pub text_layout_info: TextLayoutInfo,
     /// The calculated size based on the given image
-    pub calculated_size: CalculatedSize,
+    pub calculated_size: ContentSize,
     /// Whether this node should block interaction with lower nodes
     pub focus_policy: FocusPolicy,
     /// The transform of the node
diff --git a/crates/bevy_ui/src/widget/image.rs b/crates/bevy_ui/src/widget/image.rs
index 09ddeceebc6c5..7df81aa289627 100644
--- a/crates/bevy_ui/src/widget/image.rs
+++ b/crates/bevy_ui/src/widget/image.rs
@@ -1,4 +1,4 @@
-use crate::{measurement::AvailableSpace, CalculatedSize, Measure, Node, UiImage};
+use crate::{measurement::AvailableSpace, ContentSize, Measure, Node, UiImage};
 use bevy_asset::Assets;
 #[cfg(feature = "bevy_text")]
 use bevy_ecs::query::Without;
@@ -68,11 +68,11 @@ impl Measure for ImageMeasure {
 pub fn update_image_calculated_size_system(
     textures: Res<Assets<Image>>,
     #[cfg(feature = "bevy_text")] mut query: Query<
-        (&mut CalculatedSize, &UiImage, &mut UiImageSize),
+        (&mut ContentSize, &UiImage, &mut UiImageSize),
         (With<Node>, Without<Text>),
     >,
     #[cfg(not(feature = "bevy_text"))] mut query: Query<
-        (&mut CalculatedSize, &UiImage, &mut UiImageSize),
+        (&mut ContentSize, &UiImage, &mut UiImageSize),
         With<Node>,
     >,
 ) {
diff --git a/crates/bevy_ui/src/widget/text.rs b/crates/bevy_ui/src/widget/text.rs
index d8395d4f26f46..a9c00eb34fb73 100644
--- a/crates/bevy_ui/src/widget/text.rs
+++ b/crates/bevy_ui/src/widget/text.rs
@@ -1,4 +1,4 @@
-use crate::{CalculatedSize, Measure, Node, UiScale};
+use crate::{ContentSize, Measure, Node, UiScale};
 use bevy_asset::Assets;
 use bevy_ecs::{
     entity::Entity,
@@ -70,7 +70,7 @@ pub fn measure_text_system(
     mut text_queries: ParamSet<(
         Query<Entity, Changed<Text>>,
         Query<Entity, (With<Text>, With<Node>)>,
-        Query<(&Text, &mut CalculatedSize)>,
+        Query<(&Text, &mut ContentSize)>,
     )>,
 ) {
     let window_scale_factor = windows

From 71bd8aaef2d13ef5da2e6e612f771798f7e40f70 Mon Sep 17 00:00:00 2001
From: ickshonpe <david.curthoys@googlemail.com>
Date: Tue, 18 Apr 2023 13:59:31 +0100
Subject: [PATCH 07/20] Changed comments and variables names to refer to
 `ContentSize` not `CalculatedSize`

---
 crates/bevy_ui/src/accessibility.rs |  4 ++--
 crates/bevy_ui/src/layout/mod.rs    | 20 ++++++++++----------
 crates/bevy_ui/src/measurement.rs   |  4 ++--
 crates/bevy_ui/src/render/mod.rs    |  2 +-
 crates/bevy_ui/src/ui_node.rs       |  6 +++---
 5 files changed, 18 insertions(+), 18 deletions(-)

diff --git a/crates/bevy_ui/src/accessibility.rs b/crates/bevy_ui/src/accessibility.rs
index 42b2137e9c984..1a321c72e4916 100644
--- a/crates/bevy_ui/src/accessibility.rs
+++ b/crates/bevy_ui/src/accessibility.rs
@@ -47,8 +47,8 @@ fn calc_bounds(
                 let bounds = Rect::new(
                     translation.x.into(),
                     translation.y.into(),
-                    (translation.x + node.calculated_size.x).into(),
-                    (translation.y + node.calculated_size.y).into(),
+                    (translation.x + node.content_size.x).into(),
+                    (translation.y + node.content_size.y).into(),
                 );
                 accessible.set_bounds(bounds);
             }
diff --git a/crates/bevy_ui/src/layout/mod.rs b/crates/bevy_ui/src/layout/mod.rs
index ddf3e1a341cae..b05edfa008d3c 100644
--- a/crates/bevy_ui/src/layout/mod.rs
+++ b/crates/bevy_ui/src/layout/mod.rs
@@ -91,8 +91,8 @@ impl UiSurface {
         }
     }
 
-    pub fn update_measure(&mut self, entity: Entity, calculated_size: &ContentSize) {
-        let measure = calculated_size.measure.dyn_clone();
+    pub fn update_measure(&mut self, entity: Entity, content_size: &ContentSize) {
+        let measure = content_size.measure.dyn_clone();
         let measure_func = taffy::node::MeasureFunc::Boxed(Box::new(
             move |constraints: Size<Option<f32>>, available: Size<AvailableSpace>| {
                 let size = measure.measure(
@@ -233,7 +233,7 @@ pub fn ui_layout_system(
     measure_query: Query<(Entity, Ref<ContentSize>)>,
     children_query: Query<(Entity, &Children), (With<Node>, Changed<Children>)>,
     mut removed_children: RemovedComponents<Children>,
-    mut removed_calculated_sizes: RemovedComponents<ContentSize>,
+    mut removed_content_sizes: RemovedComponents<ContentSize>,
     mut node_transform_query: Query<(Entity, &mut Node, &mut Transform, Option<&Parent>)>,
     mut removed_nodes: RemovedComponents<Node>,
 ) {
@@ -280,17 +280,17 @@ pub fn ui_layout_system(
         }
     }
 
-    for (entity, calculated_size) in measure_query.iter() {
-        if calculated_size.is_changed() {
-            ui_surface.update_measure(entity, &calculated_size);
+    for (entity, content_size) in measure_query.iter() {
+        if content_size.is_changed() {
+            ui_surface.update_measure(entity, &content_size);
         }
     }
 
     // clean up removed nodes
     ui_surface.remove_entities(removed_nodes.iter());
 
-    // When a `CalculatedSize` component is removed from an entity, we need to remove the measure from the corresponding taffy node.
-    for entity in removed_calculated_sizes.iter() {
+    // When a `ContentSize` component is removed from an entity, we need to remove the measure from the corresponding taffy node.
+    for entity in removed_content_sizes.iter() {
         ui_surface.try_remove_measure(entity);
     }
 
@@ -320,8 +320,8 @@ pub fn ui_layout_system(
             to_logical(layout.size.height),
         );
         // only trigger change detection when the new value is different
-        if node.calculated_size != new_size {
-            node.calculated_size = new_size;
+        if node.content_size != new_size {
+            node.content_size = new_size;
         }
         let mut new_position = transform.translation;
         new_position.x = to_logical(layout.location.x + layout.size.width / 2.0);
diff --git a/crates/bevy_ui/src/measurement.rs b/crates/bevy_ui/src/measurement.rs
index 13b9e204b692c..148f7e7abd56f 100644
--- a/crates/bevy_ui/src/measurement.rs
+++ b/crates/bevy_ui/src/measurement.rs
@@ -6,7 +6,7 @@ pub use taffy::style::AvailableSpace;
 
 impl std::fmt::Debug for ContentSize {
     fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
-        f.debug_struct("CalculatedSize").finish()
+        f.debug_struct("ContentSize").finish()
     }
 }
 
@@ -49,7 +49,7 @@ impl Measure for FixedMeasure {
     }
 }
 
-/// A node with a `CalculatedSize` component is a node where its size
+/// A node with a `ContentSize` component is a node where its size
 /// is based on its content.
 #[derive(Component, Reflect)]
 pub struct ContentSize {
diff --git a/crates/bevy_ui/src/render/mod.rs b/crates/bevy_ui/src/render/mod.rs
index eb821a32f9683..b64a8233e5560 100644
--- a/crates/bevy_ui/src/render/mod.rs
+++ b/crates/bevy_ui/src/render/mod.rs
@@ -203,7 +203,7 @@ pub fn extract_uinodes(
                 color: color.0,
                 rect: Rect {
                     min: Vec2::ZERO,
-                    max: uinode.calculated_size,
+                    max: uinode.content_size,
                 },
                 image,
                 atlas_size: None,
diff --git a/crates/bevy_ui/src/ui_node.rs b/crates/bevy_ui/src/ui_node.rs
index f2093ba14f888..79f31927278e6 100644
--- a/crates/bevy_ui/src/ui_node.rs
+++ b/crates/bevy_ui/src/ui_node.rs
@@ -19,14 +19,14 @@ use thiserror::Error;
 pub struct Node {
     /// The size of the node as width and height in logical pixels
     /// automatically calculated by [`super::layout::ui_layout_system`]
-    pub(crate) calculated_size: Vec2,
+    pub(crate) content_size: Vec2,
 }
 
 impl Node {
     /// The calculated node size as width and height in logical pixels
     /// automatically calculated by [`super::layout::ui_layout_system`]
     pub fn size(&self) -> Vec2 {
-        self.calculated_size
+        self.content_size
     }
 
     /// Returns the logical pixel coordinates of the UI node, based on its `GlobalTransform`.
@@ -48,7 +48,7 @@ impl Node {
 
 impl Node {
     pub const DEFAULT: Self = Self {
-        calculated_size: Vec2::ZERO,
+        content_size: Vec2::ZERO,
     };
 }
 

From fb50589917fe8452b92f6583cfef3bfdf0e0b902 Mon Sep 17 00:00:00 2001
From: ickshonpe <david.curthoys@googlemail.com>
Date: Wed, 19 Apr 2023 23:27:21 +0100
Subject: [PATCH 08/20] Changed `ContentSize` to hold an `Option<Box<dyn
 Measurable>>` and added a new function that wraps a `Measure` into a Taffy
 `Measurable`. Changed `UiSurface::set_measure` to move the boxed `Measurable`
 from the ContentSize component to the Taffy measure slotmap without boxing or
 cloning.

---
 crates/bevy_ui/src/layout/mod.rs   | 32 ++++++++------------------
 crates/bevy_ui/src/lib.rs          |  2 +-
 crates/bevy_ui/src/measurement.rs  | 37 +++++++++++++++---------------
 crates/bevy_ui/src/node_bundles.rs |  4 ++--
 crates/bevy_ui/src/widget/image.rs | 12 ++++------
 crates/bevy_ui/src/widget/text.rs  |  8 ++-----
 6 files changed, 37 insertions(+), 58 deletions(-)

diff --git a/crates/bevy_ui/src/layout/mod.rs b/crates/bevy_ui/src/layout/mod.rs
index b05edfa008d3c..4429a73511f6d 100644
--- a/crates/bevy_ui/src/layout/mod.rs
+++ b/crates/bevy_ui/src/layout/mod.rs
@@ -18,7 +18,7 @@ use bevy_utils::HashMap;
 use bevy_window::{PrimaryWindow, Window, WindowResolution, WindowScaleFactorChanged};
 use std::fmt;
 use taffy::{
-    prelude::{AvailableSpace, Size},
+    prelude::Size,
     style_helpers::TaffyMaxContent,
     Taffy,
 };
@@ -91,25 +91,11 @@ impl UiSurface {
         }
     }
 
-    pub fn update_measure(&mut self, entity: Entity, content_size: &ContentSize) {
-        let measure = content_size.measure.dyn_clone();
-        let measure_func = taffy::node::MeasureFunc::Boxed(Box::new(
-            move |constraints: Size<Option<f32>>, available: Size<AvailableSpace>| {
-                let size = measure.measure(
-                    constraints.width,
-                    constraints.height,
-                    available.width,
-                    available.height,
-                );
-                taffy::geometry::Size {
-                    width: size.x,
-                    height: size.y,
-                }
-            },
-        ));
-
-        let taffy_node = self.entity_to_taffy.get(&entity).unwrap();
-        self.taffy.set_measure(*taffy_node, Some(measure_func)).ok();
+    pub fn update_measure(&mut self, entity: Entity, content_size: &mut ContentSize) {
+        if let Some(measure_func) = content_size.measure_func.take() {
+            let taffy_node = self.entity_to_taffy.get(&entity).unwrap();
+            self.taffy.set_measure(*taffy_node, Some(taffy::node::MeasureFunc::Boxed(measure_func))).ok();
+        }
     }
 
     pub fn update_children(&mut self, entity: Entity, children: &Children) {
@@ -230,7 +216,7 @@ pub fn ui_layout_system(
     mut ui_surface: ResMut<UiSurface>,
     root_node_query: Query<Entity, (With<Node>, Without<Parent>)>,
     style_query: Query<(Entity, Ref<Style>), With<Node>>,
-    measure_query: Query<(Entity, Ref<ContentSize>)>,
+    mut measure_query: Query<(Entity, &mut ContentSize)>,
     children_query: Query<(Entity, &Children), (With<Node>, Changed<Children>)>,
     mut removed_children: RemovedComponents<Children>,
     mut removed_content_sizes: RemovedComponents<ContentSize>,
@@ -280,9 +266,9 @@ pub fn ui_layout_system(
         }
     }
 
-    for (entity, content_size) in measure_query.iter() {
+    for (entity, mut content_size) in measure_query.iter_mut() {
         if content_size.is_changed() {
-            ui_surface.update_measure(entity, &content_size);
+            ui_surface.update_measure(entity, &mut content_size);
         }
     }
 
diff --git a/crates/bevy_ui/src/lib.rs b/crates/bevy_ui/src/lib.rs
index 05164fac4fee9..14467faf0826a 100644
--- a/crates/bevy_ui/src/lib.rs
+++ b/crates/bevy_ui/src/lib.rs
@@ -139,7 +139,7 @@ impl Plugin for UiPlugin {
         #[cfg(feature = "bevy_text")]
         app.add_plugin(accessibility::AccessibilityPlugin);
         app.add_systems(PostUpdate, {
-            let system = widget::update_image_calculated_size_system.before(UiSystem::Layout);
+            let system = widget::update_image_content_size_system.before(UiSystem::Layout);
             // Potential conflicts: `Assets<Image>`
             // They run independently since `widget::image_node_system` will only ever observe
             // its own UiImage, and `widget::text_system` & `bevy_text::update_text2d_layout`
diff --git a/crates/bevy_ui/src/measurement.rs b/crates/bevy_ui/src/measurement.rs
index 148f7e7abd56f..45eceb2a830f8 100644
--- a/crates/bevy_ui/src/measurement.rs
+++ b/crates/bevy_ui/src/measurement.rs
@@ -1,6 +1,8 @@
 use bevy_ecs::prelude::Component;
+use bevy_ecs::reflect::ReflectComponent;
 use bevy_math::Vec2;
 use bevy_reflect::Reflect;
+use taffy::node::Measurable;
 use std::fmt::Formatter;
 pub use taffy::style::AvailableSpace;
 
@@ -21,9 +23,6 @@ pub trait Measure: Send + Sync + 'static {
         available_width: AvailableSpace,
         available_height: AvailableSpace,
     ) -> Vec2;
-
-    /// Clone and box self.
-    fn dyn_clone(&self) -> Box<dyn Measure>;
 }
 
 /// A `FixedMeasure` is a `Measure` that ignores all constraints and
@@ -43,35 +42,37 @@ impl Measure for FixedMeasure {
     ) -> Vec2 {
         self.size
     }
-
-    fn dyn_clone(&self) -> Box<dyn Measure> {
-        Box::new(self.clone())
-    }
 }
 
 /// A node with a `ContentSize` component is a node where its size
 /// is based on its content.
 #[derive(Component, Reflect)]
+#[reflect(Component)]
 pub struct ContentSize {
     /// The `Measure` used to compute the intrinsic size
     #[reflect(ignore)]
-    pub measure: Box<dyn Measure>,
+    pub (crate) measure_func: Option<Box<dyn Measurable>>,
 }
 
-#[allow(clippy::derivable_impls)]
-impl Default for ContentSize {
-    fn default() -> Self {
+impl ContentSize {
+    pub fn new(measure: impl Measure) -> Self {
+        let measure_func = move |size: taffy::prelude::Size<Option<f32>>, available: taffy::prelude::Size<AvailableSpace>| {
+            let size = measure.measure(size.width, size.height, available.width, available.height);
+            taffy::prelude::Size {
+                width: size.x,
+                height: size.y,
+            }
+        };
         Self {
-            // Default `FixedMeasure` always returns zero size.
-            measure: Box::<FixedMeasure>::default(),
+            measure_func: Some(Box::new(measure_func))
         }
     }
 }
 
-impl Clone for ContentSize {
-    fn clone(&self) -> Self {
-        Self {
-            measure: self.measure.dyn_clone(),
-        }
+#[allow(clippy::derivable_impls)]
+impl Default for ContentSize {
+    fn default() -> Self {
+        Self::new(FixedMeasure::default())
     }
 }
+
diff --git a/crates/bevy_ui/src/node_bundles.rs b/crates/bevy_ui/src/node_bundles.rs
index df1fd75d104df..976ebae070afc 100644
--- a/crates/bevy_ui/src/node_bundles.rs
+++ b/crates/bevy_ui/src/node_bundles.rs
@@ -63,7 +63,7 @@ impl Default for NodeBundle {
 }
 
 /// A UI node that is an image
-#[derive(Bundle, Clone, Debug, Default)]
+#[derive(Bundle, Debug, Default)]
 pub struct ImageBundle {
     /// Describes the logical size of the node
     ///
@@ -107,7 +107,7 @@ pub struct ImageBundle {
 
 #[cfg(feature = "bevy_text")]
 /// A UI node that is text
-#[derive(Bundle, Clone, Debug)]
+#[derive(Bundle, Debug)]
 pub struct TextBundle {
     /// Describes the logical size of the node
     pub node: Node,
diff --git a/crates/bevy_ui/src/widget/image.rs b/crates/bevy_ui/src/widget/image.rs
index 7df81aa289627..1e8ef16e5fee4 100644
--- a/crates/bevy_ui/src/widget/image.rs
+++ b/crates/bevy_ui/src/widget/image.rs
@@ -58,14 +58,10 @@ impl Measure for ImageMeasure {
         }
         size
     }
-
-    fn dyn_clone(&self) -> Box<dyn Measure> {
-        Box::new(self.clone())
-    }
 }
 
-/// Updates calculated size of the node based on the image provided
-pub fn update_image_calculated_size_system(
+/// Updates content size of the node based on the image provided
+pub fn update_image_content_size_system(
     textures: Res<Assets<Image>>,
     #[cfg(feature = "bevy_text")] mut query: Query<
         (&mut ContentSize, &UiImage, &mut UiImageSize),
@@ -76,7 +72,7 @@ pub fn update_image_calculated_size_system(
         With<Node>,
     >,
 ) {
-    for (mut calculated_size, image, mut image_size) in &mut query {
+    for (mut content_size, image, mut image_size) in &mut query {
         if let Some(texture) = textures.get(&image.texture) {
             let size = Vec2::new(
                 texture.texture_descriptor.size.width as f32,
@@ -85,7 +81,7 @@ pub fn update_image_calculated_size_system(
             // Update only if size has changed to avoid needless layout calculations
             if size != image_size.size {
                 image_size.size = size;
-                calculated_size.measure = Box::new(ImageMeasure { size });
+                *content_size = ContentSize::new(ImageMeasure { size });
             }
         }
     }
diff --git a/crates/bevy_ui/src/widget/text.rs b/crates/bevy_ui/src/widget/text.rs
index a9c00eb34fb73..c35af1032b288 100644
--- a/crates/bevy_ui/src/widget/text.rs
+++ b/crates/bevy_ui/src/widget/text.rs
@@ -52,10 +52,6 @@ impl Measure for TextMeasure {
             )
             .ceil()
     }
-
-    fn dyn_clone(&self) -> Box<dyn Measure> {
-        Box::new(self.clone())
-    }
 }
 
 /// Creates a `Measure` for text nodes that allows the UI to determine the appropriate amount of space
@@ -103,7 +99,7 @@ pub fn measure_text_system(
     let mut new_queue = Vec::new();
     let mut query = text_queries.p2();
     for entity in queued_text.drain(..) {
-        if let Ok((text, mut calculated_size)) = query.get_mut(entity) {
+        if let Ok((text, mut content_size)) = query.get_mut(entity) {
             match text_pipeline.create_text_measure(
                 &fonts,
                 &text.sections,
@@ -112,7 +108,7 @@ pub fn measure_text_system(
                 text.linebreak_behavior,
             ) {
                 Ok(measure) => {
-                    calculated_size.measure = Box::new(TextMeasure { info: measure });
+                    *content_size = ContentSize::new(TextMeasure { info: measure });
                 }
                 Err(TextError::NoSuchFont) => {
                     new_queue.push(entity);

From 96903e54ee48df58a98f5110fece4d6edfb75dc0 Mon Sep 17 00:00:00 2001
From: ickshonpe <david.curthoys@googlemail.com>
Date: Thu, 20 Apr 2023 11:02:01 +0100
Subject: [PATCH 09/20] changes: * cargo fmt --all * Removed change detection
 check from `set_measure`

---
 crates/bevy_ui/src/layout/mod.rs  | 23 +++++++++++------------
 crates/bevy_ui/src/measurement.rs | 24 +++++++++++++-----------
 2 files changed, 24 insertions(+), 23 deletions(-)

diff --git a/crates/bevy_ui/src/layout/mod.rs b/crates/bevy_ui/src/layout/mod.rs
index 4429a73511f6d..9cab3506518ab 100644
--- a/crates/bevy_ui/src/layout/mod.rs
+++ b/crates/bevy_ui/src/layout/mod.rs
@@ -17,11 +17,7 @@ use bevy_transform::components::Transform;
 use bevy_utils::HashMap;
 use bevy_window::{PrimaryWindow, Window, WindowResolution, WindowScaleFactorChanged};
 use std::fmt;
-use taffy::{
-    prelude::Size,
-    style_helpers::TaffyMaxContent,
-    Taffy,
-};
+use taffy::{node::Measurable, prelude::Size, style_helpers::TaffyMaxContent, Taffy};
 
 pub struct LayoutContext {
     pub scale_factor: f64,
@@ -91,11 +87,14 @@ impl UiSurface {
         }
     }
 
-    pub fn update_measure(&mut self, entity: Entity, content_size: &mut ContentSize) {
-        if let Some(measure_func) = content_size.measure_func.take() {
-            let taffy_node = self.entity_to_taffy.get(&entity).unwrap();
-            self.taffy.set_measure(*taffy_node, Some(taffy::node::MeasureFunc::Boxed(measure_func))).ok();
-        }
+    pub fn update_measure(&mut self, entity: Entity, measure_func: Box<dyn Measurable>) {
+        let taffy_node = self.entity_to_taffy.get(&entity).unwrap();
+        self.taffy
+            .set_measure(
+                *taffy_node,
+                Some(taffy::node::MeasureFunc::Boxed(measure_func)),
+            )
+            .ok();
     }
 
     pub fn update_children(&mut self, entity: Entity, children: &Children) {
@@ -267,8 +266,8 @@ pub fn ui_layout_system(
     }
 
     for (entity, mut content_size) in measure_query.iter_mut() {
-        if content_size.is_changed() {
-            ui_surface.update_measure(entity, &mut content_size);
+        if let Some(measure_func) = content_size.measure_func.take() {
+            ui_surface.update_measure(entity, measure_func);
         }
     }
 
diff --git a/crates/bevy_ui/src/measurement.rs b/crates/bevy_ui/src/measurement.rs
index 45eceb2a830f8..a41bb4c851e7a 100644
--- a/crates/bevy_ui/src/measurement.rs
+++ b/crates/bevy_ui/src/measurement.rs
@@ -2,8 +2,8 @@ use bevy_ecs::prelude::Component;
 use bevy_ecs::reflect::ReflectComponent;
 use bevy_math::Vec2;
 use bevy_reflect::Reflect;
-use taffy::node::Measurable;
 use std::fmt::Formatter;
+use taffy::node::Measurable;
 pub use taffy::style::AvailableSpace;
 
 impl std::fmt::Debug for ContentSize {
@@ -51,20 +51,23 @@ impl Measure for FixedMeasure {
 pub struct ContentSize {
     /// The `Measure` used to compute the intrinsic size
     #[reflect(ignore)]
-    pub (crate) measure_func: Option<Box<dyn Measurable>>,
+    pub(crate) measure_func: Option<Box<dyn Measurable>>,
 }
 
 impl ContentSize {
     pub fn new(measure: impl Measure) -> Self {
-        let measure_func = move |size: taffy::prelude::Size<Option<f32>>, available: taffy::prelude::Size<AvailableSpace>| {
-            let size = measure.measure(size.width, size.height, available.width, available.height);
-            taffy::prelude::Size {
-                width: size.x,
-                height: size.y,
-            }
-        };
+        let measure_func =
+            move |size: taffy::prelude::Size<Option<f32>>,
+                  available: taffy::prelude::Size<AvailableSpace>| {
+                let size =
+                    measure.measure(size.width, size.height, available.width, available.height);
+                taffy::prelude::Size {
+                    width: size.x,
+                    height: size.y,
+                }
+            };
         Self {
-            measure_func: Some(Box::new(measure_func))
+            measure_func: Some(Box::new(measure_func)),
         }
     }
 }
@@ -75,4 +78,3 @@ impl Default for ContentSize {
         Self::new(FixedMeasure::default())
     }
 }
-

From 6385799d61b64c4ff17b58d2d78211d6ebc74630 Mon Sep 17 00:00:00 2001
From: ickshonpe <david.curthoys@googlemail.com>
Date: Thu, 20 Apr 2023 12:03:18 +0100
Subject: [PATCH 10/20] Revert "changes:"

This reverts commit 96903e54ee48df58a98f5110fece4d6edfb75dc0.
---
 crates/bevy_ui/src/layout/mod.rs  | 23 ++++++++++++-----------
 crates/bevy_ui/src/measurement.rs | 24 +++++++++++-------------
 2 files changed, 23 insertions(+), 24 deletions(-)

diff --git a/crates/bevy_ui/src/layout/mod.rs b/crates/bevy_ui/src/layout/mod.rs
index 9cab3506518ab..4429a73511f6d 100644
--- a/crates/bevy_ui/src/layout/mod.rs
+++ b/crates/bevy_ui/src/layout/mod.rs
@@ -17,7 +17,11 @@ use bevy_transform::components::Transform;
 use bevy_utils::HashMap;
 use bevy_window::{PrimaryWindow, Window, WindowResolution, WindowScaleFactorChanged};
 use std::fmt;
-use taffy::{node::Measurable, prelude::Size, style_helpers::TaffyMaxContent, Taffy};
+use taffy::{
+    prelude::Size,
+    style_helpers::TaffyMaxContent,
+    Taffy,
+};
 
 pub struct LayoutContext {
     pub scale_factor: f64,
@@ -87,14 +91,11 @@ impl UiSurface {
         }
     }
 
-    pub fn update_measure(&mut self, entity: Entity, measure_func: Box<dyn Measurable>) {
-        let taffy_node = self.entity_to_taffy.get(&entity).unwrap();
-        self.taffy
-            .set_measure(
-                *taffy_node,
-                Some(taffy::node::MeasureFunc::Boxed(measure_func)),
-            )
-            .ok();
+    pub fn update_measure(&mut self, entity: Entity, content_size: &mut ContentSize) {
+        if let Some(measure_func) = content_size.measure_func.take() {
+            let taffy_node = self.entity_to_taffy.get(&entity).unwrap();
+            self.taffy.set_measure(*taffy_node, Some(taffy::node::MeasureFunc::Boxed(measure_func))).ok();
+        }
     }
 
     pub fn update_children(&mut self, entity: Entity, children: &Children) {
@@ -266,8 +267,8 @@ pub fn ui_layout_system(
     }
 
     for (entity, mut content_size) in measure_query.iter_mut() {
-        if let Some(measure_func) = content_size.measure_func.take() {
-            ui_surface.update_measure(entity, measure_func);
+        if content_size.is_changed() {
+            ui_surface.update_measure(entity, &mut content_size);
         }
     }
 
diff --git a/crates/bevy_ui/src/measurement.rs b/crates/bevy_ui/src/measurement.rs
index a41bb4c851e7a..45eceb2a830f8 100644
--- a/crates/bevy_ui/src/measurement.rs
+++ b/crates/bevy_ui/src/measurement.rs
@@ -2,8 +2,8 @@ use bevy_ecs::prelude::Component;
 use bevy_ecs::reflect::ReflectComponent;
 use bevy_math::Vec2;
 use bevy_reflect::Reflect;
-use std::fmt::Formatter;
 use taffy::node::Measurable;
+use std::fmt::Formatter;
 pub use taffy::style::AvailableSpace;
 
 impl std::fmt::Debug for ContentSize {
@@ -51,23 +51,20 @@ impl Measure for FixedMeasure {
 pub struct ContentSize {
     /// The `Measure` used to compute the intrinsic size
     #[reflect(ignore)]
-    pub(crate) measure_func: Option<Box<dyn Measurable>>,
+    pub (crate) measure_func: Option<Box<dyn Measurable>>,
 }
 
 impl ContentSize {
     pub fn new(measure: impl Measure) -> Self {
-        let measure_func =
-            move |size: taffy::prelude::Size<Option<f32>>,
-                  available: taffy::prelude::Size<AvailableSpace>| {
-                let size =
-                    measure.measure(size.width, size.height, available.width, available.height);
-                taffy::prelude::Size {
-                    width: size.x,
-                    height: size.y,
-                }
-            };
+        let measure_func = move |size: taffy::prelude::Size<Option<f32>>, available: taffy::prelude::Size<AvailableSpace>| {
+            let size = measure.measure(size.width, size.height, available.width, available.height);
+            taffy::prelude::Size {
+                width: size.x,
+                height: size.y,
+            }
+        };
         Self {
-            measure_func: Some(Box::new(measure_func)),
+            measure_func: Some(Box::new(measure_func))
         }
     }
 }
@@ -78,3 +75,4 @@ impl Default for ContentSize {
         Self::new(FixedMeasure::default())
     }
 }
+

From 3849a09ecc63628b8594c80425870cc800ba15e6 Mon Sep 17 00:00:00 2001
From: ickshonpe <david.curthoys@googlemail.com>
Date: Thu, 20 Apr 2023 12:04:31 +0100
Subject: [PATCH 11/20] This reverts commit
 fb50589917fe8452b92f6583cfef3bfdf0e0b902.

---
 crates/bevy_ui/src/layout/mod.rs   | 32 ++++++++++++++++++--------
 crates/bevy_ui/src/lib.rs          |  2 +-
 crates/bevy_ui/src/measurement.rs  | 37 +++++++++++++++---------------
 crates/bevy_ui/src/node_bundles.rs |  4 ++--
 crates/bevy_ui/src/widget/image.rs | 12 ++++++----
 crates/bevy_ui/src/widget/text.rs  |  8 +++++--
 6 files changed, 58 insertions(+), 37 deletions(-)

diff --git a/crates/bevy_ui/src/layout/mod.rs b/crates/bevy_ui/src/layout/mod.rs
index 4429a73511f6d..b05edfa008d3c 100644
--- a/crates/bevy_ui/src/layout/mod.rs
+++ b/crates/bevy_ui/src/layout/mod.rs
@@ -18,7 +18,7 @@ use bevy_utils::HashMap;
 use bevy_window::{PrimaryWindow, Window, WindowResolution, WindowScaleFactorChanged};
 use std::fmt;
 use taffy::{
-    prelude::Size,
+    prelude::{AvailableSpace, Size},
     style_helpers::TaffyMaxContent,
     Taffy,
 };
@@ -91,11 +91,25 @@ impl UiSurface {
         }
     }
 
-    pub fn update_measure(&mut self, entity: Entity, content_size: &mut ContentSize) {
-        if let Some(measure_func) = content_size.measure_func.take() {
-            let taffy_node = self.entity_to_taffy.get(&entity).unwrap();
-            self.taffy.set_measure(*taffy_node, Some(taffy::node::MeasureFunc::Boxed(measure_func))).ok();
-        }
+    pub fn update_measure(&mut self, entity: Entity, content_size: &ContentSize) {
+        let measure = content_size.measure.dyn_clone();
+        let measure_func = taffy::node::MeasureFunc::Boxed(Box::new(
+            move |constraints: Size<Option<f32>>, available: Size<AvailableSpace>| {
+                let size = measure.measure(
+                    constraints.width,
+                    constraints.height,
+                    available.width,
+                    available.height,
+                );
+                taffy::geometry::Size {
+                    width: size.x,
+                    height: size.y,
+                }
+            },
+        ));
+
+        let taffy_node = self.entity_to_taffy.get(&entity).unwrap();
+        self.taffy.set_measure(*taffy_node, Some(measure_func)).ok();
     }
 
     pub fn update_children(&mut self, entity: Entity, children: &Children) {
@@ -216,7 +230,7 @@ pub fn ui_layout_system(
     mut ui_surface: ResMut<UiSurface>,
     root_node_query: Query<Entity, (With<Node>, Without<Parent>)>,
     style_query: Query<(Entity, Ref<Style>), With<Node>>,
-    mut measure_query: Query<(Entity, &mut ContentSize)>,
+    measure_query: Query<(Entity, Ref<ContentSize>)>,
     children_query: Query<(Entity, &Children), (With<Node>, Changed<Children>)>,
     mut removed_children: RemovedComponents<Children>,
     mut removed_content_sizes: RemovedComponents<ContentSize>,
@@ -266,9 +280,9 @@ pub fn ui_layout_system(
         }
     }
 
-    for (entity, mut content_size) in measure_query.iter_mut() {
+    for (entity, content_size) in measure_query.iter() {
         if content_size.is_changed() {
-            ui_surface.update_measure(entity, &mut content_size);
+            ui_surface.update_measure(entity, &content_size);
         }
     }
 
diff --git a/crates/bevy_ui/src/lib.rs b/crates/bevy_ui/src/lib.rs
index 14467faf0826a..05164fac4fee9 100644
--- a/crates/bevy_ui/src/lib.rs
+++ b/crates/bevy_ui/src/lib.rs
@@ -139,7 +139,7 @@ impl Plugin for UiPlugin {
         #[cfg(feature = "bevy_text")]
         app.add_plugin(accessibility::AccessibilityPlugin);
         app.add_systems(PostUpdate, {
-            let system = widget::update_image_content_size_system.before(UiSystem::Layout);
+            let system = widget::update_image_calculated_size_system.before(UiSystem::Layout);
             // Potential conflicts: `Assets<Image>`
             // They run independently since `widget::image_node_system` will only ever observe
             // its own UiImage, and `widget::text_system` & `bevy_text::update_text2d_layout`
diff --git a/crates/bevy_ui/src/measurement.rs b/crates/bevy_ui/src/measurement.rs
index 45eceb2a830f8..148f7e7abd56f 100644
--- a/crates/bevy_ui/src/measurement.rs
+++ b/crates/bevy_ui/src/measurement.rs
@@ -1,8 +1,6 @@
 use bevy_ecs::prelude::Component;
-use bevy_ecs::reflect::ReflectComponent;
 use bevy_math::Vec2;
 use bevy_reflect::Reflect;
-use taffy::node::Measurable;
 use std::fmt::Formatter;
 pub use taffy::style::AvailableSpace;
 
@@ -23,6 +21,9 @@ pub trait Measure: Send + Sync + 'static {
         available_width: AvailableSpace,
         available_height: AvailableSpace,
     ) -> Vec2;
+
+    /// Clone and box self.
+    fn dyn_clone(&self) -> Box<dyn Measure>;
 }
 
 /// A `FixedMeasure` is a `Measure` that ignores all constraints and
@@ -42,37 +43,35 @@ impl Measure for FixedMeasure {
     ) -> Vec2 {
         self.size
     }
+
+    fn dyn_clone(&self) -> Box<dyn Measure> {
+        Box::new(self.clone())
+    }
 }
 
 /// A node with a `ContentSize` component is a node where its size
 /// is based on its content.
 #[derive(Component, Reflect)]
-#[reflect(Component)]
 pub struct ContentSize {
     /// The `Measure` used to compute the intrinsic size
     #[reflect(ignore)]
-    pub (crate) measure_func: Option<Box<dyn Measurable>>,
+    pub measure: Box<dyn Measure>,
 }
 
-impl ContentSize {
-    pub fn new(measure: impl Measure) -> Self {
-        let measure_func = move |size: taffy::prelude::Size<Option<f32>>, available: taffy::prelude::Size<AvailableSpace>| {
-            let size = measure.measure(size.width, size.height, available.width, available.height);
-            taffy::prelude::Size {
-                width: size.x,
-                height: size.y,
-            }
-        };
+#[allow(clippy::derivable_impls)]
+impl Default for ContentSize {
+    fn default() -> Self {
         Self {
-            measure_func: Some(Box::new(measure_func))
+            // Default `FixedMeasure` always returns zero size.
+            measure: Box::<FixedMeasure>::default(),
         }
     }
 }
 
-#[allow(clippy::derivable_impls)]
-impl Default for ContentSize {
-    fn default() -> Self {
-        Self::new(FixedMeasure::default())
+impl Clone for ContentSize {
+    fn clone(&self) -> Self {
+        Self {
+            measure: self.measure.dyn_clone(),
+        }
     }
 }
-
diff --git a/crates/bevy_ui/src/node_bundles.rs b/crates/bevy_ui/src/node_bundles.rs
index 976ebae070afc..df1fd75d104df 100644
--- a/crates/bevy_ui/src/node_bundles.rs
+++ b/crates/bevy_ui/src/node_bundles.rs
@@ -63,7 +63,7 @@ impl Default for NodeBundle {
 }
 
 /// A UI node that is an image
-#[derive(Bundle, Debug, Default)]
+#[derive(Bundle, Clone, Debug, Default)]
 pub struct ImageBundle {
     /// Describes the logical size of the node
     ///
@@ -107,7 +107,7 @@ pub struct ImageBundle {
 
 #[cfg(feature = "bevy_text")]
 /// A UI node that is text
-#[derive(Bundle, Debug)]
+#[derive(Bundle, Clone, Debug)]
 pub struct TextBundle {
     /// Describes the logical size of the node
     pub node: Node,
diff --git a/crates/bevy_ui/src/widget/image.rs b/crates/bevy_ui/src/widget/image.rs
index 1e8ef16e5fee4..7df81aa289627 100644
--- a/crates/bevy_ui/src/widget/image.rs
+++ b/crates/bevy_ui/src/widget/image.rs
@@ -58,10 +58,14 @@ impl Measure for ImageMeasure {
         }
         size
     }
+
+    fn dyn_clone(&self) -> Box<dyn Measure> {
+        Box::new(self.clone())
+    }
 }
 
-/// Updates content size of the node based on the image provided
-pub fn update_image_content_size_system(
+/// Updates calculated size of the node based on the image provided
+pub fn update_image_calculated_size_system(
     textures: Res<Assets<Image>>,
     #[cfg(feature = "bevy_text")] mut query: Query<
         (&mut ContentSize, &UiImage, &mut UiImageSize),
@@ -72,7 +76,7 @@ pub fn update_image_content_size_system(
         With<Node>,
     >,
 ) {
-    for (mut content_size, image, mut image_size) in &mut query {
+    for (mut calculated_size, image, mut image_size) in &mut query {
         if let Some(texture) = textures.get(&image.texture) {
             let size = Vec2::new(
                 texture.texture_descriptor.size.width as f32,
@@ -81,7 +85,7 @@ pub fn update_image_content_size_system(
             // Update only if size has changed to avoid needless layout calculations
             if size != image_size.size {
                 image_size.size = size;
-                *content_size = ContentSize::new(ImageMeasure { size });
+                calculated_size.measure = Box::new(ImageMeasure { size });
             }
         }
     }
diff --git a/crates/bevy_ui/src/widget/text.rs b/crates/bevy_ui/src/widget/text.rs
index c35af1032b288..a9c00eb34fb73 100644
--- a/crates/bevy_ui/src/widget/text.rs
+++ b/crates/bevy_ui/src/widget/text.rs
@@ -52,6 +52,10 @@ impl Measure for TextMeasure {
             )
             .ceil()
     }
+
+    fn dyn_clone(&self) -> Box<dyn Measure> {
+        Box::new(self.clone())
+    }
 }
 
 /// Creates a `Measure` for text nodes that allows the UI to determine the appropriate amount of space
@@ -99,7 +103,7 @@ pub fn measure_text_system(
     let mut new_queue = Vec::new();
     let mut query = text_queries.p2();
     for entity in queued_text.drain(..) {
-        if let Ok((text, mut content_size)) = query.get_mut(entity) {
+        if let Ok((text, mut calculated_size)) = query.get_mut(entity) {
             match text_pipeline.create_text_measure(
                 &fonts,
                 &text.sections,
@@ -108,7 +112,7 @@ pub fn measure_text_system(
                 text.linebreak_behavior,
             ) {
                 Ok(measure) => {
-                    *content_size = ContentSize::new(TextMeasure { info: measure });
+                    calculated_size.measure = Box::new(TextMeasure { info: measure });
                 }
                 Err(TextError::NoSuchFont) => {
                     new_queue.push(entity);

From 0f10753c8ee78ce9996f2a83046557348cb0f3ab Mon Sep 17 00:00:00 2001
From: ickshonpe <david.curthoys@googlemail.com>
Date: Thu, 20 Apr 2023 18:24:31 +0100
Subject: [PATCH 12/20] This reverts commit
 3849a09ecc63628b8594c80425870cc800ba15e6.

---
 crates/bevy_ui/src/layout/mod.rs   | 32 ++++++++------------------
 crates/bevy_ui/src/lib.rs          |  2 +-
 crates/bevy_ui/src/measurement.rs  | 37 +++++++++++++++---------------
 crates/bevy_ui/src/node_bundles.rs |  4 ++--
 crates/bevy_ui/src/widget/image.rs | 12 ++++------
 crates/bevy_ui/src/widget/text.rs  |  8 ++-----
 6 files changed, 37 insertions(+), 58 deletions(-)

diff --git a/crates/bevy_ui/src/layout/mod.rs b/crates/bevy_ui/src/layout/mod.rs
index b05edfa008d3c..4429a73511f6d 100644
--- a/crates/bevy_ui/src/layout/mod.rs
+++ b/crates/bevy_ui/src/layout/mod.rs
@@ -18,7 +18,7 @@ use bevy_utils::HashMap;
 use bevy_window::{PrimaryWindow, Window, WindowResolution, WindowScaleFactorChanged};
 use std::fmt;
 use taffy::{
-    prelude::{AvailableSpace, Size},
+    prelude::Size,
     style_helpers::TaffyMaxContent,
     Taffy,
 };
@@ -91,25 +91,11 @@ impl UiSurface {
         }
     }
 
-    pub fn update_measure(&mut self, entity: Entity, content_size: &ContentSize) {
-        let measure = content_size.measure.dyn_clone();
-        let measure_func = taffy::node::MeasureFunc::Boxed(Box::new(
-            move |constraints: Size<Option<f32>>, available: Size<AvailableSpace>| {
-                let size = measure.measure(
-                    constraints.width,
-                    constraints.height,
-                    available.width,
-                    available.height,
-                );
-                taffy::geometry::Size {
-                    width: size.x,
-                    height: size.y,
-                }
-            },
-        ));
-
-        let taffy_node = self.entity_to_taffy.get(&entity).unwrap();
-        self.taffy.set_measure(*taffy_node, Some(measure_func)).ok();
+    pub fn update_measure(&mut self, entity: Entity, content_size: &mut ContentSize) {
+        if let Some(measure_func) = content_size.measure_func.take() {
+            let taffy_node = self.entity_to_taffy.get(&entity).unwrap();
+            self.taffy.set_measure(*taffy_node, Some(taffy::node::MeasureFunc::Boxed(measure_func))).ok();
+        }
     }
 
     pub fn update_children(&mut self, entity: Entity, children: &Children) {
@@ -230,7 +216,7 @@ pub fn ui_layout_system(
     mut ui_surface: ResMut<UiSurface>,
     root_node_query: Query<Entity, (With<Node>, Without<Parent>)>,
     style_query: Query<(Entity, Ref<Style>), With<Node>>,
-    measure_query: Query<(Entity, Ref<ContentSize>)>,
+    mut measure_query: Query<(Entity, &mut ContentSize)>,
     children_query: Query<(Entity, &Children), (With<Node>, Changed<Children>)>,
     mut removed_children: RemovedComponents<Children>,
     mut removed_content_sizes: RemovedComponents<ContentSize>,
@@ -280,9 +266,9 @@ pub fn ui_layout_system(
         }
     }
 
-    for (entity, content_size) in measure_query.iter() {
+    for (entity, mut content_size) in measure_query.iter_mut() {
         if content_size.is_changed() {
-            ui_surface.update_measure(entity, &content_size);
+            ui_surface.update_measure(entity, &mut content_size);
         }
     }
 
diff --git a/crates/bevy_ui/src/lib.rs b/crates/bevy_ui/src/lib.rs
index 05164fac4fee9..14467faf0826a 100644
--- a/crates/bevy_ui/src/lib.rs
+++ b/crates/bevy_ui/src/lib.rs
@@ -139,7 +139,7 @@ impl Plugin for UiPlugin {
         #[cfg(feature = "bevy_text")]
         app.add_plugin(accessibility::AccessibilityPlugin);
         app.add_systems(PostUpdate, {
-            let system = widget::update_image_calculated_size_system.before(UiSystem::Layout);
+            let system = widget::update_image_content_size_system.before(UiSystem::Layout);
             // Potential conflicts: `Assets<Image>`
             // They run independently since `widget::image_node_system` will only ever observe
             // its own UiImage, and `widget::text_system` & `bevy_text::update_text2d_layout`
diff --git a/crates/bevy_ui/src/measurement.rs b/crates/bevy_ui/src/measurement.rs
index 148f7e7abd56f..45eceb2a830f8 100644
--- a/crates/bevy_ui/src/measurement.rs
+++ b/crates/bevy_ui/src/measurement.rs
@@ -1,6 +1,8 @@
 use bevy_ecs::prelude::Component;
+use bevy_ecs::reflect::ReflectComponent;
 use bevy_math::Vec2;
 use bevy_reflect::Reflect;
+use taffy::node::Measurable;
 use std::fmt::Formatter;
 pub use taffy::style::AvailableSpace;
 
@@ -21,9 +23,6 @@ pub trait Measure: Send + Sync + 'static {
         available_width: AvailableSpace,
         available_height: AvailableSpace,
     ) -> Vec2;
-
-    /// Clone and box self.
-    fn dyn_clone(&self) -> Box<dyn Measure>;
 }
 
 /// A `FixedMeasure` is a `Measure` that ignores all constraints and
@@ -43,35 +42,37 @@ impl Measure for FixedMeasure {
     ) -> Vec2 {
         self.size
     }
-
-    fn dyn_clone(&self) -> Box<dyn Measure> {
-        Box::new(self.clone())
-    }
 }
 
 /// A node with a `ContentSize` component is a node where its size
 /// is based on its content.
 #[derive(Component, Reflect)]
+#[reflect(Component)]
 pub struct ContentSize {
     /// The `Measure` used to compute the intrinsic size
     #[reflect(ignore)]
-    pub measure: Box<dyn Measure>,
+    pub (crate) measure_func: Option<Box<dyn Measurable>>,
 }
 
-#[allow(clippy::derivable_impls)]
-impl Default for ContentSize {
-    fn default() -> Self {
+impl ContentSize {
+    pub fn new(measure: impl Measure) -> Self {
+        let measure_func = move |size: taffy::prelude::Size<Option<f32>>, available: taffy::prelude::Size<AvailableSpace>| {
+            let size = measure.measure(size.width, size.height, available.width, available.height);
+            taffy::prelude::Size {
+                width: size.x,
+                height: size.y,
+            }
+        };
         Self {
-            // Default `FixedMeasure` always returns zero size.
-            measure: Box::<FixedMeasure>::default(),
+            measure_func: Some(Box::new(measure_func))
         }
     }
 }
 
-impl Clone for ContentSize {
-    fn clone(&self) -> Self {
-        Self {
-            measure: self.measure.dyn_clone(),
-        }
+#[allow(clippy::derivable_impls)]
+impl Default for ContentSize {
+    fn default() -> Self {
+        Self::new(FixedMeasure::default())
     }
 }
+
diff --git a/crates/bevy_ui/src/node_bundles.rs b/crates/bevy_ui/src/node_bundles.rs
index df1fd75d104df..976ebae070afc 100644
--- a/crates/bevy_ui/src/node_bundles.rs
+++ b/crates/bevy_ui/src/node_bundles.rs
@@ -63,7 +63,7 @@ impl Default for NodeBundle {
 }
 
 /// A UI node that is an image
-#[derive(Bundle, Clone, Debug, Default)]
+#[derive(Bundle, Debug, Default)]
 pub struct ImageBundle {
     /// Describes the logical size of the node
     ///
@@ -107,7 +107,7 @@ pub struct ImageBundle {
 
 #[cfg(feature = "bevy_text")]
 /// A UI node that is text
-#[derive(Bundle, Clone, Debug)]
+#[derive(Bundle, Debug)]
 pub struct TextBundle {
     /// Describes the logical size of the node
     pub node: Node,
diff --git a/crates/bevy_ui/src/widget/image.rs b/crates/bevy_ui/src/widget/image.rs
index 7df81aa289627..1e8ef16e5fee4 100644
--- a/crates/bevy_ui/src/widget/image.rs
+++ b/crates/bevy_ui/src/widget/image.rs
@@ -58,14 +58,10 @@ impl Measure for ImageMeasure {
         }
         size
     }
-
-    fn dyn_clone(&self) -> Box<dyn Measure> {
-        Box::new(self.clone())
-    }
 }
 
-/// Updates calculated size of the node based on the image provided
-pub fn update_image_calculated_size_system(
+/// Updates content size of the node based on the image provided
+pub fn update_image_content_size_system(
     textures: Res<Assets<Image>>,
     #[cfg(feature = "bevy_text")] mut query: Query<
         (&mut ContentSize, &UiImage, &mut UiImageSize),
@@ -76,7 +72,7 @@ pub fn update_image_calculated_size_system(
         With<Node>,
     >,
 ) {
-    for (mut calculated_size, image, mut image_size) in &mut query {
+    for (mut content_size, image, mut image_size) in &mut query {
         if let Some(texture) = textures.get(&image.texture) {
             let size = Vec2::new(
                 texture.texture_descriptor.size.width as f32,
@@ -85,7 +81,7 @@ pub fn update_image_calculated_size_system(
             // Update only if size has changed to avoid needless layout calculations
             if size != image_size.size {
                 image_size.size = size;
-                calculated_size.measure = Box::new(ImageMeasure { size });
+                *content_size = ContentSize::new(ImageMeasure { size });
             }
         }
     }
diff --git a/crates/bevy_ui/src/widget/text.rs b/crates/bevy_ui/src/widget/text.rs
index a9c00eb34fb73..c35af1032b288 100644
--- a/crates/bevy_ui/src/widget/text.rs
+++ b/crates/bevy_ui/src/widget/text.rs
@@ -52,10 +52,6 @@ impl Measure for TextMeasure {
             )
             .ceil()
     }
-
-    fn dyn_clone(&self) -> Box<dyn Measure> {
-        Box::new(self.clone())
-    }
 }
 
 /// Creates a `Measure` for text nodes that allows the UI to determine the appropriate amount of space
@@ -103,7 +99,7 @@ pub fn measure_text_system(
     let mut new_queue = Vec::new();
     let mut query = text_queries.p2();
     for entity in queued_text.drain(..) {
-        if let Ok((text, mut calculated_size)) = query.get_mut(entity) {
+        if let Ok((text, mut content_size)) = query.get_mut(entity) {
             match text_pipeline.create_text_measure(
                 &fonts,
                 &text.sections,
@@ -112,7 +108,7 @@ pub fn measure_text_system(
                 text.linebreak_behavior,
             ) {
                 Ok(measure) => {
-                    calculated_size.measure = Box::new(TextMeasure { info: measure });
+                    *content_size = ContentSize::new(TextMeasure { info: measure });
                 }
                 Err(TextError::NoSuchFont) => {
                     new_queue.push(entity);

From a118920b3d5c06681093349c43ab9daa47c82c07 Mon Sep 17 00:00:00 2001
From: ickshonpe <david.curthoys@googlemail.com>
Date: Thu, 20 Apr 2023 18:25:07 +0100
Subject: [PATCH 13/20] This reverts commit
 6385799d61b64c4ff17b58d2d78211d6ebc74630.

---
 crates/bevy_ui/src/layout/mod.rs  | 23 +++++++++++------------
 crates/bevy_ui/src/measurement.rs | 24 +++++++++++++-----------
 2 files changed, 24 insertions(+), 23 deletions(-)

diff --git a/crates/bevy_ui/src/layout/mod.rs b/crates/bevy_ui/src/layout/mod.rs
index 4429a73511f6d..9cab3506518ab 100644
--- a/crates/bevy_ui/src/layout/mod.rs
+++ b/crates/bevy_ui/src/layout/mod.rs
@@ -17,11 +17,7 @@ use bevy_transform::components::Transform;
 use bevy_utils::HashMap;
 use bevy_window::{PrimaryWindow, Window, WindowResolution, WindowScaleFactorChanged};
 use std::fmt;
-use taffy::{
-    prelude::Size,
-    style_helpers::TaffyMaxContent,
-    Taffy,
-};
+use taffy::{node::Measurable, prelude::Size, style_helpers::TaffyMaxContent, Taffy};
 
 pub struct LayoutContext {
     pub scale_factor: f64,
@@ -91,11 +87,14 @@ impl UiSurface {
         }
     }
 
-    pub fn update_measure(&mut self, entity: Entity, content_size: &mut ContentSize) {
-        if let Some(measure_func) = content_size.measure_func.take() {
-            let taffy_node = self.entity_to_taffy.get(&entity).unwrap();
-            self.taffy.set_measure(*taffy_node, Some(taffy::node::MeasureFunc::Boxed(measure_func))).ok();
-        }
+    pub fn update_measure(&mut self, entity: Entity, measure_func: Box<dyn Measurable>) {
+        let taffy_node = self.entity_to_taffy.get(&entity).unwrap();
+        self.taffy
+            .set_measure(
+                *taffy_node,
+                Some(taffy::node::MeasureFunc::Boxed(measure_func)),
+            )
+            .ok();
     }
 
     pub fn update_children(&mut self, entity: Entity, children: &Children) {
@@ -267,8 +266,8 @@ pub fn ui_layout_system(
     }
 
     for (entity, mut content_size) in measure_query.iter_mut() {
-        if content_size.is_changed() {
-            ui_surface.update_measure(entity, &mut content_size);
+        if let Some(measure_func) = content_size.measure_func.take() {
+            ui_surface.update_measure(entity, measure_func);
         }
     }
 
diff --git a/crates/bevy_ui/src/measurement.rs b/crates/bevy_ui/src/measurement.rs
index 45eceb2a830f8..a41bb4c851e7a 100644
--- a/crates/bevy_ui/src/measurement.rs
+++ b/crates/bevy_ui/src/measurement.rs
@@ -2,8 +2,8 @@ use bevy_ecs::prelude::Component;
 use bevy_ecs::reflect::ReflectComponent;
 use bevy_math::Vec2;
 use bevy_reflect::Reflect;
-use taffy::node::Measurable;
 use std::fmt::Formatter;
+use taffy::node::Measurable;
 pub use taffy::style::AvailableSpace;
 
 impl std::fmt::Debug for ContentSize {
@@ -51,20 +51,23 @@ impl Measure for FixedMeasure {
 pub struct ContentSize {
     /// The `Measure` used to compute the intrinsic size
     #[reflect(ignore)]
-    pub (crate) measure_func: Option<Box<dyn Measurable>>,
+    pub(crate) measure_func: Option<Box<dyn Measurable>>,
 }
 
 impl ContentSize {
     pub fn new(measure: impl Measure) -> Self {
-        let measure_func = move |size: taffy::prelude::Size<Option<f32>>, available: taffy::prelude::Size<AvailableSpace>| {
-            let size = measure.measure(size.width, size.height, available.width, available.height);
-            taffy::prelude::Size {
-                width: size.x,
-                height: size.y,
-            }
-        };
+        let measure_func =
+            move |size: taffy::prelude::Size<Option<f32>>,
+                  available: taffy::prelude::Size<AvailableSpace>| {
+                let size =
+                    measure.measure(size.width, size.height, available.width, available.height);
+                taffy::prelude::Size {
+                    width: size.x,
+                    height: size.y,
+                }
+            };
         Self {
-            measure_func: Some(Box::new(measure_func))
+            measure_func: Some(Box::new(measure_func)),
         }
     }
 }
@@ -75,4 +78,3 @@ impl Default for ContentSize {
         Self::new(FixedMeasure::default())
     }
 }
-

From 8b0365d00a89751d20d70421aa8be5f8fa2a43e1 Mon Sep 17 00:00:00 2001
From: ickshonpe <david.curthoys@googlemail.com>
Date: Fri, 21 Apr 2023 08:40:28 +0100
Subject: [PATCH 14/20] changes: * Removed the `new` function from
 `ContentSize`. * Changed the `measure_func` field of `ContentSize` to an
 `Option<taffy::node::MeasureFunc>`. This puts all the `MeasureFunc` wrapping
 code is in one place and allows us to use an unboxed function as a
 `MeasureFunc`. * Added `set` and `set_fn` methods to `ContentSize` to replace
 the `new` function. * Default zero-size measure uses an unboxed closure
 instead of a boxed `Measure`. * Removed the `FixedMeasure` type, which is no
 longer needed as an unboxed function is simpler and more efficient.

---
 crates/bevy_ui/src/measurement.rs  | 40 +++++++++++-------------------
 crates/bevy_ui/src/widget/image.rs |  2 +-
 crates/bevy_ui/src/widget/text.rs  |  2 +-
 3 files changed, 17 insertions(+), 27 deletions(-)

diff --git a/crates/bevy_ui/src/measurement.rs b/crates/bevy_ui/src/measurement.rs
index a41bb4c851e7a..52895d34bc9eb 100644
--- a/crates/bevy_ui/src/measurement.rs
+++ b/crates/bevy_ui/src/measurement.rs
@@ -25,25 +25,6 @@ pub trait Measure: Send + Sync + 'static {
     ) -> Vec2;
 }
 
-/// A `FixedMeasure` is a `Measure` that ignores all constraints and
-/// always returns the same size.
-#[derive(Default, Clone)]
-pub struct FixedMeasure {
-    size: Vec2,
-}
-
-impl Measure for FixedMeasure {
-    fn measure(
-        &self,
-        _: Option<f32>,
-        _: Option<f32>,
-        _: AvailableSpace,
-        _: AvailableSpace,
-    ) -> Vec2 {
-        self.size
-    }
-}
-
 /// A node with a `ContentSize` component is a node where its size
 /// is based on its content.
 #[derive(Component, Reflect)]
@@ -51,11 +32,12 @@ impl Measure for FixedMeasure {
 pub struct ContentSize {
     /// The `Measure` used to compute the intrinsic size
     #[reflect(ignore)]
-    pub(crate) measure_func: Option<Box<dyn Measurable>>,
+    pub(crate) measure_func: Option<taffy::node::MeasureFunc>,
 }
 
 impl ContentSize {
-    pub fn new(measure: impl Measure) -> Self {
+    /// Set a `Measure` for this function
+    pub fn set(&mut self, measure: impl Measure) {
         let measure_func =
             move |size: taffy::prelude::Size<Option<f32>>,
                   available: taffy::prelude::Size<AvailableSpace>| {
@@ -66,15 +48,23 @@ impl ContentSize {
                     height: size.y,
                 }
             };
-        Self {
-            measure_func: Some(Box::new(measure_func)),
-        }
+        self.measure_func = Some(taffy::node::MeasureFunc::Boxed(Box::new(measure_func)));
+    }
+
+    /// Use an unboxed function to determine the size for this content
+    pub fn set_fn(
+        &mut self,
+        measure: impl Fn(Option<f32>, Option<f32>, AvailableSpace, AvailableSpace) -> Vec2,
+    ) {
+        self.measure_func = Some(taffy::node::MeasureFunc::Raw(measure));
     }
 }
 
 #[allow(clippy::derivable_impls)]
 impl Default for ContentSize {
     fn default() -> Self {
-        Self::new(FixedMeasure::default())
+        Self {
+            measure_func: Some(taffy::node::MeasureFunc::Raw(|_, _, _, _| Size::ZERO)),
+        }
     }
 }
diff --git a/crates/bevy_ui/src/widget/image.rs b/crates/bevy_ui/src/widget/image.rs
index 1e8ef16e5fee4..57cfdd953c83d 100644
--- a/crates/bevy_ui/src/widget/image.rs
+++ b/crates/bevy_ui/src/widget/image.rs
@@ -81,7 +81,7 @@ pub fn update_image_content_size_system(
             // Update only if size has changed to avoid needless layout calculations
             if size != image_size.size {
                 image_size.size = size;
-                *content_size = ContentSize::new(ImageMeasure { size });
+                content_size.set(ImageMeasure { size });
             }
         }
     }
diff --git a/crates/bevy_ui/src/widget/text.rs b/crates/bevy_ui/src/widget/text.rs
index c35af1032b288..9102b9fc8d23e 100644
--- a/crates/bevy_ui/src/widget/text.rs
+++ b/crates/bevy_ui/src/widget/text.rs
@@ -108,7 +108,7 @@ pub fn measure_text_system(
                 text.linebreak_behavior,
             ) {
                 Ok(measure) => {
-                    *content_size = ContentSize::new(TextMeasure { info: measure });
+                    content_size.set(TextMeasure { info: measure });
                 }
                 Err(TextError::NoSuchFont) => {
                     new_queue.push(entity);

From acd290d08f4908a8319c48f5a239a7e2cd14e924 Mon Sep 17 00:00:00 2001
From: ickshonpe <david.curthoys@googlemail.com>
Date: Fri, 21 Apr 2023 09:18:21 +0100
Subject: [PATCH 15/20] Added doc comments for the functions in the `layout`
 module.

---
 crates/bevy_ui/src/layout/mod.rs  | 10 ++++++++++
 crates/bevy_ui/src/measurement.rs |  2 +-
 2 files changed, 11 insertions(+), 1 deletion(-)

diff --git a/crates/bevy_ui/src/layout/mod.rs b/crates/bevy_ui/src/layout/mod.rs
index 9cab3506518ab..a36b655b98981 100644
--- a/crates/bevy_ui/src/layout/mod.rs
+++ b/crates/bevy_ui/src/layout/mod.rs
@@ -72,6 +72,8 @@ impl Default for UiSurface {
 }
 
 impl UiSurface {
+    /// Retrieves the taffy node corresponding to given entity exists, or inserts a new taffy node into the layout if no corresponding node exists.
+    /// Then convert the given `Style` and use it update the taffy node's style.
     pub fn upsert_node(&mut self, entity: Entity, style: &Style, context: &LayoutContext) {
         let mut added = false;
         let taffy = &mut self.taffy;
@@ -87,6 +89,7 @@ impl UiSurface {
         }
     }
 
+    /// Update the `MeasureFunc` of the taffy node corresponding to the given [`Entity`].
     pub fn update_measure(&mut self, entity: Entity, measure_func: Box<dyn Measurable>) {
         let taffy_node = self.entity_to_taffy.get(&entity).unwrap();
         self.taffy
@@ -97,6 +100,7 @@ impl UiSurface {
             .ok();
     }
 
+    /// Update the children of the taffy node corresponding to the given [`Entity`].
     pub fn update_children(&mut self, entity: Entity, children: &Children) {
         let mut taffy_children = Vec::with_capacity(children.len());
         for child in children {
@@ -130,6 +134,7 @@ without UI components as a child of an entity with UI components, results may be
         }
     }
 
+    /// Retrieve or insert the root layout node and update its size to match the size of the window.
     pub fn update_window(&mut self, window: Entity, window_resolution: &WindowResolution) {
         let taffy = &mut self.taffy;
         let node = self
@@ -155,6 +160,7 @@ without UI components as a child of an entity with UI components, results may be
             .unwrap();
     }
 
+    /// Set the ui node entities without a [`Parent`] as children to the root node in the taffy layout.
     pub fn set_window_children(
         &mut self,
         parent_window: Entity,
@@ -167,6 +173,7 @@ without UI components as a child of an entity with UI components, results may be
         self.taffy.set_children(*taffy_node, &child_nodes).unwrap();
     }
 
+    /// Compute the layout for each window entity's corresponding root node in the layout.
     pub fn compute_window_layouts(&mut self) {
         for window_node in self.window_nodes.values() {
             self.taffy
@@ -184,6 +191,8 @@ without UI components as a child of an entity with UI components, results may be
         }
     }
 
+    /// Get the layout geometry for the taffy node corresponding to the ui node [`Entity`].
+    /// Does not compute the layout geometry, `compute_window_layouts` should be run before using this function.
     pub fn get_layout(&self, entity: Entity) -> Result<&taffy::layout::Layout, LayoutError> {
         if let Some(taffy_node) = self.entity_to_taffy.get(&entity) {
             self.taffy
@@ -205,6 +214,7 @@ pub enum LayoutError {
     TaffyError(taffy::error::TaffyError),
 }
 
+/// Updates the UI's layout tree, computes the new layout geometry and then updates the sizes and transforms of all the UI nodes.
 #[allow(clippy::too_many_arguments)]
 pub fn ui_layout_system(
     primary_window: Query<(Entity, &Window), With<PrimaryWindow>>,
diff --git a/crates/bevy_ui/src/measurement.rs b/crates/bevy_ui/src/measurement.rs
index 52895d34bc9eb..90ef50600a817 100644
--- a/crates/bevy_ui/src/measurement.rs
+++ b/crates/bevy_ui/src/measurement.rs
@@ -51,7 +51,7 @@ impl ContentSize {
         self.measure_func = Some(taffy::node::MeasureFunc::Boxed(Box::new(measure_func)));
     }
 
-    /// Use an unboxed function to determine the size for this content
+    /// Use an unboxed function to compute the size of this content
     pub fn set_fn(
         &mut self,
         measure: impl Fn(Option<f32>, Option<f32>, AvailableSpace, AvailableSpace) -> Vec2,

From 47d85107a185bb47a2c9bd958f5c0196859271cd Mon Sep 17 00:00:00 2001
From: ickshonpe <david.curthoys@googlemail.com>
Date: Fri, 21 Apr 2023 10:09:58 +0100
Subject: [PATCH 16/20] changes * Removed `set_fn`. * Returned `FixedMeasure`.
 * Fixed `default` implementation for `ContentSize`.

---
 crates/bevy_ui/src/measurement.rs | 32 +++++++++++++++++++++----------
 1 file changed, 22 insertions(+), 10 deletions(-)

diff --git a/crates/bevy_ui/src/measurement.rs b/crates/bevy_ui/src/measurement.rs
index 90ef50600a817..82571b7ccd2a6 100644
--- a/crates/bevy_ui/src/measurement.rs
+++ b/crates/bevy_ui/src/measurement.rs
@@ -3,7 +3,6 @@ use bevy_ecs::reflect::ReflectComponent;
 use bevy_math::Vec2;
 use bevy_reflect::Reflect;
 use std::fmt::Formatter;
-use taffy::node::Measurable;
 pub use taffy::style::AvailableSpace;
 
 impl std::fmt::Debug for ContentSize {
@@ -25,6 +24,26 @@ pub trait Measure: Send + Sync + 'static {
     ) -> Vec2;
 }
 
+
+/// A `FixedMeasure` is a `Measure` that ignores all constraints and
+/// always returns the same size.
+#[derive(Default, Clone)]
+pub struct FixedMeasure {
+    size: Vec2,
+}
+
+impl Measure for FixedMeasure {
+    fn measure(
+        &self,
+        _: Option<f32>,
+        _: Option<f32>,
+        _: AvailableSpace,
+        _: AvailableSpace,
+    ) -> Vec2 {
+        self.size
+    }
+}
+
 /// A node with a `ContentSize` component is a node where its size
 /// is based on its content.
 #[derive(Component, Reflect)]
@@ -50,21 +69,14 @@ impl ContentSize {
             };
         self.measure_func = Some(taffy::node::MeasureFunc::Boxed(Box::new(measure_func)));
     }
-
-    /// Use an unboxed function to compute the size of this content
-    pub fn set_fn(
-        &mut self,
-        measure: impl Fn(Option<f32>, Option<f32>, AvailableSpace, AvailableSpace) -> Vec2,
-    ) {
-        self.measure_func = Some(taffy::node::MeasureFunc::Raw(measure));
-    }
 }
 
 #[allow(clippy::derivable_impls)]
 impl Default for ContentSize {
     fn default() -> Self {
         Self {
-            measure_func: Some(taffy::node::MeasureFunc::Raw(|_, _, _, _| Size::ZERO)),
+            measure_func: Some(taffy::node::MeasureFunc::Raw(|_, _| taffy::prelude::Size::ZERO)),
         }
     }
 }
+

From 4a236524954b531c454bfa115a3c4f5731d0dfe8 Mon Sep 17 00:00:00 2001
From: ickshonpe <david.curthoys@googlemail.com>
Date: Fri, 21 Apr 2023 10:12:20 +0100
Subject: [PATCH 17/20] fix imports

---
 crates/bevy_ui/src/layout/mod.rs | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/crates/bevy_ui/src/layout/mod.rs b/crates/bevy_ui/src/layout/mod.rs
index a36b655b98981..6f5f402497365 100644
--- a/crates/bevy_ui/src/layout/mod.rs
+++ b/crates/bevy_ui/src/layout/mod.rs
@@ -17,7 +17,7 @@ use bevy_transform::components::Transform;
 use bevy_utils::HashMap;
 use bevy_window::{PrimaryWindow, Window, WindowResolution, WindowScaleFactorChanged};
 use std::fmt;
-use taffy::{node::Measurable, prelude::Size, style_helpers::TaffyMaxContent, Taffy};
+use taffy::{prelude::Size, style_helpers::TaffyMaxContent, Taffy};
 
 pub struct LayoutContext {
     pub scale_factor: f64,
@@ -90,12 +90,12 @@ impl UiSurface {
     }
 
     /// Update the `MeasureFunc` of the taffy node corresponding to the given [`Entity`].
-    pub fn update_measure(&mut self, entity: Entity, measure_func: Box<dyn Measurable>) {
+    pub fn update_measure(&mut self, entity: Entity, measure_func: taffy::node::MeasureFunc) {
         let taffy_node = self.entity_to_taffy.get(&entity).unwrap();
         self.taffy
             .set_measure(
                 *taffy_node,
-                Some(taffy::node::MeasureFunc::Boxed(measure_func)),
+                Some(measure_func),
             )
             .ok();
     }

From 00b515f201c56407e444b29f2555d405634cb11f Mon Sep 17 00:00:00 2001
From: ickshonpe <david.curthoys@googlemail.com>
Date: Fri, 21 Apr 2023 10:16:07 +0100
Subject: [PATCH 18/20] cargo fmt

---
 crates/bevy_ui/src/layout/mod.rs  | 7 +------
 crates/bevy_ui/src/measurement.rs | 6 +++---
 2 files changed, 4 insertions(+), 9 deletions(-)

diff --git a/crates/bevy_ui/src/layout/mod.rs b/crates/bevy_ui/src/layout/mod.rs
index 6f5f402497365..857dbd8c48849 100644
--- a/crates/bevy_ui/src/layout/mod.rs
+++ b/crates/bevy_ui/src/layout/mod.rs
@@ -92,12 +92,7 @@ impl UiSurface {
     /// Update the `MeasureFunc` of the taffy node corresponding to the given [`Entity`].
     pub fn update_measure(&mut self, entity: Entity, measure_func: taffy::node::MeasureFunc) {
         let taffy_node = self.entity_to_taffy.get(&entity).unwrap();
-        self.taffy
-            .set_measure(
-                *taffy_node,
-                Some(measure_func),
-            )
-            .ok();
+        self.taffy.set_measure(*taffy_node, Some(measure_func)).ok();
     }
 
     /// Update the children of the taffy node corresponding to the given [`Entity`].
diff --git a/crates/bevy_ui/src/measurement.rs b/crates/bevy_ui/src/measurement.rs
index 82571b7ccd2a6..cdb89e7152c88 100644
--- a/crates/bevy_ui/src/measurement.rs
+++ b/crates/bevy_ui/src/measurement.rs
@@ -24,7 +24,6 @@ pub trait Measure: Send + Sync + 'static {
     ) -> Vec2;
 }
 
-
 /// A `FixedMeasure` is a `Measure` that ignores all constraints and
 /// always returns the same size.
 #[derive(Default, Clone)]
@@ -75,8 +74,9 @@ impl ContentSize {
 impl Default for ContentSize {
     fn default() -> Self {
         Self {
-            measure_func: Some(taffy::node::MeasureFunc::Raw(|_, _| taffy::prelude::Size::ZERO)),
+            measure_func: Some(taffy::node::MeasureFunc::Raw(|_, _| {
+                taffy::prelude::Size::ZERO
+            })),
         }
     }
 }
-

From 4142a78d842f1fa5bc5b6186f2b02e7725a57844 Mon Sep 17 00:00:00 2001
From: ickshonpe <david.curthoys@googlemail.com>
Date: Fri, 21 Apr 2023 12:52:04 +0100
Subject: [PATCH 19/20] changed `Node` field name back to `calculated_size`

---
 crates/bevy_ui/src/accessibility.rs | 4 ++--
 crates/bevy_ui/src/layout/mod.rs    | 4 ++--
 crates/bevy_ui/src/render/mod.rs    | 2 +-
 crates/bevy_ui/src/ui_node.rs       | 6 +++---
 4 files changed, 8 insertions(+), 8 deletions(-)

diff --git a/crates/bevy_ui/src/accessibility.rs b/crates/bevy_ui/src/accessibility.rs
index 1a321c72e4916..42b2137e9c984 100644
--- a/crates/bevy_ui/src/accessibility.rs
+++ b/crates/bevy_ui/src/accessibility.rs
@@ -47,8 +47,8 @@ fn calc_bounds(
                 let bounds = Rect::new(
                     translation.x.into(),
                     translation.y.into(),
-                    (translation.x + node.content_size.x).into(),
-                    (translation.y + node.content_size.y).into(),
+                    (translation.x + node.calculated_size.x).into(),
+                    (translation.y + node.calculated_size.y).into(),
                 );
                 accessible.set_bounds(bounds);
             }
diff --git a/crates/bevy_ui/src/layout/mod.rs b/crates/bevy_ui/src/layout/mod.rs
index 857dbd8c48849..75dc688f8b811 100644
--- a/crates/bevy_ui/src/layout/mod.rs
+++ b/crates/bevy_ui/src/layout/mod.rs
@@ -310,8 +310,8 @@ pub fn ui_layout_system(
             to_logical(layout.size.height),
         );
         // only trigger change detection when the new value is different
-        if node.content_size != new_size {
-            node.content_size = new_size;
+        if node.calculated_size != new_size {
+            node.calculated_size = new_size;
         }
         let mut new_position = transform.translation;
         new_position.x = to_logical(layout.location.x + layout.size.width / 2.0);
diff --git a/crates/bevy_ui/src/render/mod.rs b/crates/bevy_ui/src/render/mod.rs
index b64a8233e5560..eb821a32f9683 100644
--- a/crates/bevy_ui/src/render/mod.rs
+++ b/crates/bevy_ui/src/render/mod.rs
@@ -203,7 +203,7 @@ pub fn extract_uinodes(
                 color: color.0,
                 rect: Rect {
                     min: Vec2::ZERO,
-                    max: uinode.content_size,
+                    max: uinode.calculated_size,
                 },
                 image,
                 atlas_size: None,
diff --git a/crates/bevy_ui/src/ui_node.rs b/crates/bevy_ui/src/ui_node.rs
index 79f31927278e6..f2093ba14f888 100644
--- a/crates/bevy_ui/src/ui_node.rs
+++ b/crates/bevy_ui/src/ui_node.rs
@@ -19,14 +19,14 @@ use thiserror::Error;
 pub struct Node {
     /// The size of the node as width and height in logical pixels
     /// automatically calculated by [`super::layout::ui_layout_system`]
-    pub(crate) content_size: Vec2,
+    pub(crate) calculated_size: Vec2,
 }
 
 impl Node {
     /// The calculated node size as width and height in logical pixels
     /// automatically calculated by [`super::layout::ui_layout_system`]
     pub fn size(&self) -> Vec2 {
-        self.content_size
+        self.calculated_size
     }
 
     /// Returns the logical pixel coordinates of the UI node, based on its `GlobalTransform`.
@@ -48,7 +48,7 @@ impl Node {
 
 impl Node {
     pub const DEFAULT: Self = Self {
-        content_size: Vec2::ZERO,
+        calculated_size: Vec2::ZERO,
     };
 }
 

From c6c62d283d04079c5485b0b30b9d996b6dedc17f Mon Sep 17 00:00:00 2001
From: ickshonpe <david.curthoys@googlemail.com>
Date: Sun, 30 Apr 2023 01:09:41 +0100
Subject: [PATCH 20/20] cargo fmt

---
 crates/bevy_ui/src/layout/mod.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/crates/bevy_ui/src/layout/mod.rs b/crates/bevy_ui/src/layout/mod.rs
index 22fd473940736..75dc688f8b811 100644
--- a/crates/bevy_ui/src/layout/mod.rs
+++ b/crates/bevy_ui/src/layout/mod.rs
@@ -327,4 +327,4 @@ pub fn ui_layout_system(
             transform.translation = new_position;
         }
     }
-}
\ No newline at end of file
+}