Convert algorithms to traitified styles

Author: nicoburns

src/compute/block.rs

@@ -1,6 +1,6 @@
 //! Computes the CSS block layout algorithm in the case that the block container being laid out contains only block-level boxes
 use crate::geometry::{Line, Point, Rect, Size};
-use crate::style::{AvailableSpace, Display, LengthPercentageAuto, Overflow, Position};
+use crate::style::{AvailableSpace, CoreStyle, LengthPercentageAuto, Overflow, Position};
 use crate::style_helpers::TaffyMaxContent;
 use crate::tree::{CollapsibleMarginSet, Layout, LayoutInput, LayoutOutput, RunMode, SizingMode};
 use crate::tree::{LayoutPartialTree, LayoutPartialTreeExt, NodeId};
@@ -9,6 +9,7 @@ use crate::util::sys::f32_max;
 use crate::util::sys::Vec;
 use crate::util::MaybeMath;
 use crate::util::{MaybeResolve, ResolveOrZero};
+use crate::{BoxGenerationMode, LayoutBlockContainer};
 
 #[cfg(feature = "content_size")]
 use super::common::content_size::compute_content_size_contribution;
@@ -56,25 +57,31 @@ struct BlockItem {
     can_be_collapsed_through: bool,
 }
 
-/// Computes the layout of [`LayoutPartialTree`] according to the block layout algorithm
-pub fn compute_block_layout(tree: &mut impl LayoutPartialTree, node_id: NodeId, inputs: LayoutInput) -> LayoutOutput {
+/// Computes the layout of [`LayoutBlockContainer`] according to the block layout algorithm
+pub fn compute_block_layout(
+    tree: &mut impl LayoutBlockContainer,
+    node_id: NodeId,
+    inputs: LayoutInput,
+) -> LayoutOutput {
     let LayoutInput { known_dimensions, parent_size, available_space, run_mode, .. } = inputs;
-    let style = tree.get_style(node_id);
+    let style = tree.get_block_container_style(node_id);
 
     // Pull these out earlier to avoid borrowing issues
-    let aspect_ratio = style.aspect_ratio;
-    let margin = style.margin.resolve_or_zero(parent_size.width);
-    let min_size = style.min_size.maybe_resolve(parent_size).maybe_apply_aspect_ratio(aspect_ratio);
-    let max_size = style.max_size.maybe_resolve(parent_size).maybe_apply_aspect_ratio(aspect_ratio);
-    let padding = style.padding.resolve_or_zero(parent_size.width);
-    let border = style.border.resolve_or_zero(parent_size.width);
+    let aspect_ratio = style.aspect_ratio();
+    let margin = style.margin().resolve_or_zero(parent_size.width);
+    let min_size = style.min_size().maybe_resolve(parent_size).maybe_apply_aspect_ratio(aspect_ratio);
+    let max_size = style.max_size().maybe_resolve(parent_size).maybe_apply_aspect_ratio(aspect_ratio);
+    let padding = style.padding().resolve_or_zero(parent_size.width);
+    let border = style.border().resolve_or_zero(parent_size.width);
     let padding_border_size = (padding + border).sum_axes();
     let clamped_style_size = if inputs.sizing_mode == SizingMode::InherentSize {
-        style.size.maybe_resolve(parent_size).maybe_apply_aspect_ratio(aspect_ratio).maybe_clamp(min_size, max_size)
+        style.size().maybe_resolve(parent_size).maybe_apply_aspect_ratio(aspect_ratio).maybe_clamp(min_size, max_size)
     } else {
         Size::NONE
     };
 
+    drop(style);
+
     // If both min and max in a given axis are set and max <= min then this determines the size in that axis
     let min_max_definite_size = min_size.zip_map(max_size, |min, max| match (min, max) {
         (Some(min), Some(max)) if max <= min => Some(min),
@@ -103,29 +110,29 @@ pub fn compute_block_layout(tree: &mut impl LayoutPartialTree, node_id: NodeId,
     compute_inner(tree, node_id, LayoutInput { known_dimensions: styled_based_known_dimensions, ..inputs })
 }
 
-/// Computes the layout of [`LayoutPartialTree`] according to the block layout algorithm
-fn compute_inner(tree: &mut impl LayoutPartialTree, node_id: NodeId, inputs: LayoutInput) -> LayoutOutput {
+/// Computes the layout of [`LayoutBlockContainer`] according to the block layout algorithm
+fn compute_inner(tree: &mut impl LayoutBlockContainer, node_id: NodeId, inputs: LayoutInput) -> LayoutOutput {
     let LayoutInput {
         known_dimensions, parent_size, available_space, run_mode, vertical_margins_are_collapsible, ..
     } = inputs;
 
-    let style = tree.get_style(node_id);
-    let raw_padding = style.padding;
-    let raw_border = style.border;
-    let raw_margin = style.margin;
-    let aspect_ratio = style.aspect_ratio;
-    let size = style.size.maybe_resolve(parent_size).maybe_apply_aspect_ratio(aspect_ratio);
-    let min_size = style.min_size.maybe_resolve(parent_size).maybe_apply_aspect_ratio(aspect_ratio);
-    let max_size = style.max_size.maybe_resolve(parent_size).maybe_apply_aspect_ratio(aspect_ratio);
-    let padding = style.padding.resolve_or_zero(parent_size.width);
-    let border = style.border.resolve_or_zero(parent_size.width);
+    let style = tree.get_block_container_style(node_id);
+    let raw_padding = style.padding();
+    let raw_border = style.border();
+    let raw_margin = style.margin();
+    let aspect_ratio = style.aspect_ratio();
+    let size = style.size().maybe_resolve(parent_size).maybe_apply_aspect_ratio(aspect_ratio);
+    let min_size = style.min_size().maybe_resolve(parent_size).maybe_apply_aspect_ratio(aspect_ratio);
+    let max_size = style.max_size().maybe_resolve(parent_size).maybe_apply_aspect_ratio(aspect_ratio);
+    let padding = style.padding().resolve_or_zero(parent_size.width);
+    let border = style.border().resolve_or_zero(parent_size.width);
 
     // Scrollbar gutters are reserved when the `overflow` property is set to `Overflow::Scroll`.
     // However, the axis are switched (transposed) because a node that scrolls vertically needs
     // *horizontal* space to be reserved for a scrollbar
     let scrollbar_gutter = {
-        let offsets = style.overflow.transpose().map(|overflow| match overflow {
-            Overflow::Scroll => style.scrollbar_width,
+        let offsets = style.overflow().transpose().map(|overflow| match overflow {
+            Overflow::Scroll => style.scrollbar_width(),
             _ => 0.0,
         });
         // TODO: make side configurable based on the `direction` property
@@ -139,28 +146,30 @@ fn compute_inner(tree: &mut impl LayoutPartialTree, node_id: NodeId, inputs: Lay
     // Determine margin collapsing behaviour
     let own_margins_collapse_with_children = Line {
         start: vertical_margins_are_collapsible.start
-            && !style.overflow.x.is_scroll_container()
-            && !style.overflow.y.is_scroll_container()
-            && style.position == Position::Relative
+            && !style.overflow().x.is_scroll_container()
+            && !style.overflow().y.is_scroll_container()
+            && style.position() == Position::Relative
             && padding.top == 0.0
             && border.top == 0.0,
         end: vertical_margins_are_collapsible.end
-            && !style.overflow.x.is_scroll_container()
-            && !style.overflow.y.is_scroll_container()
-            && style.position == Position::Relative
+            && !style.overflow().x.is_scroll_container()
+            && !style.overflow().y.is_scroll_container()
+            && style.position() == Position::Relative
             && padding.bottom == 0.0
             && border.bottom == 0.0
             && size.height.is_none(),
     };
-    let has_styles_preventing_being_collapsed_through = style.display != Display::Block
-        || style.overflow.x.is_scroll_container()
-        || style.overflow.y.is_scroll_container()
-        || style.position == Position::Absolute
+    let has_styles_preventing_being_collapsed_through = false//style.display != Display::Block
+        || style.overflow().x.is_scroll_container()
+        || style.overflow().y.is_scroll_container()
+        || style.position() == Position::Absolute
         || padding.top > 0.0
         || padding.bottom > 0.0
         || border.top > 0.0
         || border.bottom > 0.0;
 
+    drop(style);
+
     // 1. Generate items
     let mut items = generate_item_list(tree, node_id, container_content_box_size);
 
@@ -212,7 +221,7 @@ fn compute_inner(tree: &mut impl LayoutPartialTree, node_id: NodeId, inputs: Lay
     let len = tree.child_count(node_id);
     for order in 0..len {
         let child = tree.get_child_id(node_id, order);
-        if tree.get_style(child).display == Display::None {
+        if tree.get_block_child_style(child).box_generation_mode() == BoxGenerationMode::None {
             tree.set_unrounded_layout(child, &Layout::with_order(order as u32));
             tree.perform_child_layout(
                 child,
@@ -258,30 +267,30 @@ fn compute_inner(tree: &mut impl LayoutPartialTree, node_id: NodeId, inputs: Lay
 /// Create a `Vec` of `BlockItem` structs where each item in the `Vec` represents a child of the current node
 #[inline]
 fn generate_item_list(
-    tree: &impl LayoutPartialTree,
+    tree: &impl LayoutBlockContainer,
     node: NodeId,
     node_inner_size: Size<Option<f32>>,
 ) -> Vec<BlockItem> {
     tree.child_ids(node)
-        .map(|child_node_id| (child_node_id, tree.get_style(child_node_id)))
-        .filter(|(_, style)| style.display != Display::None)
+        .map(|child_node_id| (child_node_id, tree.get_block_child_style(child_node_id)))
+        .filter(|(_, style)| style.box_generation_mode() != BoxGenerationMode::None)
         .enumerate()
         .map(|(order, (child_node_id, child_style))| {
-            let aspect_ratio = child_style.aspect_ratio;
-            let padding = child_style.padding.resolve_or_zero(node_inner_size);
-            let border = child_style.border.resolve_or_zero(node_inner_size);
+            let aspect_ratio = child_style.aspect_ratio();
+            let padding = child_style.padding().resolve_or_zero(node_inner_size);
+            let border = child_style.border().resolve_or_zero(node_inner_size);
             BlockItem {
                 node_id: child_node_id,
                 order: order as u32,
 
-                size: child_style.size.maybe_resolve(node_inner_size).maybe_apply_aspect_ratio(aspect_ratio),
-                min_size: child_style.min_size.maybe_resolve(node_inner_size).maybe_apply_aspect_ratio(aspect_ratio),
-                max_size: child_style.max_size.maybe_resolve(node_inner_size).maybe_apply_aspect_ratio(aspect_ratio),
-                overflow: child_style.overflow,
-                scrollbar_width: child_style.scrollbar_width,
-                position: child_style.position,
-                inset: child_style.inset,
-                margin: child_style.margin,
+                size: child_style.size().maybe_resolve(node_inner_size).maybe_apply_aspect_ratio(aspect_ratio),
+                min_size: child_style.min_size().maybe_resolve(node_inner_size).maybe_apply_aspect_ratio(aspect_ratio),
+                max_size: child_style.max_size().maybe_resolve(node_inner_size).maybe_apply_aspect_ratio(aspect_ratio),
+                overflow: child_style.overflow(),
+                scrollbar_width: child_style.scrollbar_width(),
+                position: child_style.position(),
+                inset: child_style.inset(),
+                margin: child_style.margin(),
                 padding,
                 border,
                 padding_border_sum: (padding + border).sum_axes(),
@@ -488,7 +497,7 @@ fn perform_final_layout_on_in_flow_children(
 /// Perform absolute layout on all absolutely positioned children.
 #[inline]
 fn perform_absolute_layout_on_absolute_children(
-    tree: &mut impl LayoutPartialTree,
+    tree: &mut impl LayoutBlockContainer,
     items: &[BlockItem],
     area_size: Size<f32>,
     area_offset: Point<f32>,
@@ -500,36 +509,39 @@ fn perform_absolute_layout_on_absolute_children(
     let mut absolute_content_size = Size::ZERO;
 
     for item in items.iter().filter(|item| item.position == Position::Absolute) {
-        let child_style = tree.get_style(item.node_id);
+        let child_style = tree.get_block_child_style(item.node_id);
 
         // Skip items that are display:none or are not position:absolute
-        if child_style.display == Display::None || child_style.position != Position::Absolute {
+        if child_style.box_generation_mode() == BoxGenerationMode::None || child_style.position() != Position::Absolute
+        {
             continue;
         }
 
-        let aspect_ratio = child_style.aspect_ratio;
-        let margin = child_style.margin.map(|margin| margin.resolve_to_option(area_width));
-        let padding = child_style.padding.resolve_or_zero(Some(area_width));
-        let border = child_style.border.resolve_or_zero(Some(area_width));
+        let aspect_ratio = child_style.aspect_ratio();
+        let margin = child_style.margin().map(|margin| margin.resolve_to_option(area_width));
+        let padding = child_style.padding().resolve_or_zero(Some(area_width));
+        let border = child_style.border().resolve_or_zero(Some(area_width));
         let padding_border_sum = (padding + border).sum_axes();
 
         // Resolve inset
-        let left = child_style.inset.left.maybe_resolve(area_width);
-        let right = child_style.inset.right.maybe_resolve(area_width);
-        let top = child_style.inset.top.maybe_resolve(area_height);
-        let bottom = child_style.inset.bottom.maybe_resolve(area_height);
+        let left = child_style.inset().left.maybe_resolve(area_width);
+        let right = child_style.inset().right.maybe_resolve(area_width);
+        let top = child_style.inset().top.maybe_resolve(area_height);
+        let bottom = child_style.inset().bottom.maybe_resolve(area_height);
 
         // Compute known dimensions from min/max/inherent size styles
-        let style_size = child_style.size.maybe_resolve(area_size).maybe_apply_aspect_ratio(aspect_ratio);
+        let style_size = child_style.size().maybe_resolve(area_size).maybe_apply_aspect_ratio(aspect_ratio);
         let min_size = child_style
-            .min_size
+            .min_size()
             .maybe_resolve(area_size)
             .maybe_apply_aspect_ratio(aspect_ratio)
             .or(padding_border_sum.map(Some))
             .maybe_max(padding_border_sum);
-        let max_size = child_style.max_size.maybe_resolve(area_size).maybe_apply_aspect_ratio(aspect_ratio);
+        let max_size = child_style.max_size().maybe_resolve(area_size).maybe_apply_aspect_ratio(aspect_ratio);
         let mut known_dimensions = style_size.maybe_clamp(min_size, max_size);
 
+        drop(child_style);
+
         // Fill in width from left/right and reapply aspect ratio if:
         //   - Width is not already known
         //   - Item has both left and right inset properties set