Initial impl of find_content_slot + block ifc child placement

nicoburns · nicoburns · commit e66b66a4929c · 2025-10-14T15:17:37.000+01:00
Signed-off-by: Nico Burns &lt;nico@nicoburns.com&gt;
diff --git a/src/compute/block.rs b/src/compute/block.rs
@@ -14,7 +14,7 @@ use crate::{
 };
 
 #[cfg(feature = "float_layout")]
-use super::{FloatContext, FloatDirection};
+use super::{ContentSlot, FloatContext, FloatDirection};
 #[cfg(feature = "float_layout")]
 use crate::{Clear, Float};
 
@@ -93,6 +93,13 @@ impl BlockContext<'_> {
         pos
     }
 
+    pub fn find_content_slot(&self, min_y: f32, clear: Clear, after: Option<usize>) -> ContentSlot {
+        let mut slot = self.bfc.float_context.find_content_slot(min_y + self.y_offset, self.insets, clear, after);
+        slot.y -= self.y_offset;
+        slot.x -= self.insets[0];
+        slot
+    }
+
     fn add_child_floated_content_height_contribution(&mut self, child_contribution: f32) {
         self.float_content_contribution = self.float_content_contribution.max(child_contribution);
     }
@@ -476,12 +483,15 @@ fn generate_item_list(
                 if child_style.box_sizing() == BoxSizing::ContentBox { pb_sum } else { Size::ZERO };
 
             let position = child_style.position();
+            let overflow = child_style.overflow();
             let float = child_style.float();
 
             let is_block = child_style.is_block();
             let is_table = child_style.is_table();
+            let is_scroll_container = overflow.x.is_scroll_container() || overflow.y.is_scroll_container();
 
-            let is_in_same_bfc: bool = is_block && !is_table && position != Position::Absolute && float == Float::None;
+            let is_in_same_bfc: bool =
+                is_block && !is_table && position != Position::Absolute && float == Float::None && !is_scroll_container;
 
             BlockItem {
                 node_id: child_node_id,
@@ -507,7 +517,7 @@ fn generate_item_list(
                     .maybe_resolve(node_inner_size, |val, basis| tree.calc(val, basis))
                     .maybe_apply_aspect_ratio(aspect_ratio)
                     .maybe_add(box_sizing_adjustment),
-                overflow: child_style.overflow(),
+                overflow,
                 scrollbar_width: child_style.scrollbar_width(),
                 position,
                 inset: child_style.inset(),
@@ -669,18 +679,27 @@ fn perform_final_layout_on_in_flow_children(
 
             // Handle non-floated boxes
 
+            let (stretch_width, float_avoiding_position) = if item.is_in_same_bfc {
+                let stretch_width = container_inner_width - item_non_auto_x_margin_sum;
+                let position = Point { x: 0.0, y: 0.0 };
+
+                (stretch_width, position)
+            } else {
+                let min_y = committed_y_offset + active_collapsible_margin_set.resolve();
+                let slot = block_ctx.find_content_slot(min_y, item.clear, None);
+                let stretch_width = slot.width - item_non_auto_x_margin_sum;
+
+                (stretch_width, Point { x: slot.x, y: slot.y })
+            };
+
             let known_dimensions = if item.is_table {
                 Size::NONE
             } else {
                 item.size
                     .map_width(|width| {
                         // TODO: Allow stretch-sizing to be conditional, as there are exceptions.
                         // e.g. Table children of blocks do not stretch fit
-                        Some(
-                            width
-                                .unwrap_or(container_inner_width - item_non_auto_x_margin_sum)
-                                .maybe_clamp(item.min_size.width, item.max_size.width),
-                        )
+                        Some(width.unwrap_or(stretch_width).maybe_clamp(item.min_size.width, item.max_size.width))
                     })
                     .maybe_clamp(item.min_size, item.max_size)
             };
@@ -727,7 +746,7 @@ fn perform_final_layout_on_in_flow_children(
             // Expand auto margins to fill available space
             // Note: Vertical auto-margins for relatively positioned block items simply resolve to 0.
             // See: https://www.w3.org/TR/CSS21/visudet.html#abs-non-replaced-width
-            let free_x_space = f32_max(0.0, container_inner_width - final_size.width - item_non_auto_x_margin_sum);
+            let free_x_space = f32_max(0.0, stretch_width - final_size.width);
             let x_axis_auto_margin_size = {
                 let auto_margin_count = item_margin.left.is_none() as u8 + item_margin.right.is_none() as u8;
                 if auto_margin_count > 0 {
@@ -760,27 +779,43 @@ fn perform_final_layout_on_in_flow_children(
 
             item.computed_size = item_layout.size;
             item.can_be_collapsed_through = item_layout.margins_can_collapse_through;
-            item.static_position = Point {
-                x: resolved_content_box_inset.left,
-                y: committed_y_offset + active_collapsible_margin_set.resolve(),
+            item.static_position = if item.is_in_same_bfc {
+                Point {
+                    x: resolved_content_box_inset.left,
+                    y: committed_y_offset + active_collapsible_margin_set.resolve(),
+                }
+            } else {
+                // TODO: handle inset and margins
+                Point { x: float_avoiding_position.x + resolved_content_box_inset.left, y: float_avoiding_position.y }
             };
-            let mut location = Point {
-                x: resolved_content_box_inset.left + inset_offset.x + resolved_margin.left,
-                y: committed_y_offset + inset_offset.y + y_margin_offset,
+            let mut location = if item.is_in_same_bfc {
+                Point {
+                    x: resolved_content_box_inset.left + inset_offset.x + resolved_margin.left,
+                    y: committed_y_offset + inset_offset.y + y_margin_offset,
+                }
+            } else {
+                // TODO: handle inset and margins
+                Point {
+                    x: float_avoiding_position.x
+                        + resolved_content_box_inset.left
+                        + inset_offset.x
+                        + resolved_margin.left,
+                    y: float_avoiding_position.y + inset_offset.y + y_margin_offset,
+                }
             };
 
             // Apply alignment
             let item_outer_width = item_layout.size.width + resolved_margin.horizontal_axis_sum();
-            if item_outer_width < container_inner_width {
+            if item_outer_width < stretch_width {
                 match text_align {
                     TextAlign::Auto => {
                         // Do nothing
                     }
                     TextAlign::LegacyLeft => {
                         // Do nothing. Left aligned by default.
                     }
-                    TextAlign::LegacyRight => location.x += container_inner_width - item_outer_width,
-                    TextAlign::LegacyCenter => location.x += (container_inner_width - item_outer_width) / 2.0,
+                    TextAlign::LegacyRight => location.x += stretch_width - item_outer_width,
+                    TextAlign::LegacyCenter => location.x += (stretch_width - item_outer_width) / 2.0,
                 }
             }
 
diff --git a/src/compute/float.rs b/src/compute/float.rs
@@ -26,7 +26,7 @@
 //!
 //! <https://www.w3.org/TR/CSS22/visuren.html#floats>
 
-use core::ops::{Range, RangeInclusive};
+use core::ops::Range;
 
 use crate::{AvailableSpace, Clear, Point, Size};
 
@@ -50,6 +50,17 @@ pub enum FloatDirection {
     Right = 1,
 }
 
+/// An empty "slot" that avoids floats that is suitable for non-floated content
+/// to be laid out into
+#[derive(Debug, Clone, Copy, Default)]
+pub struct ContentSlot {
+    pub segment_id: Option<usize>,
+    pub x: f32,
+    pub y: f32,
+    pub width: f32,
+    pub height: f32,
+}
+
 /// A floated box to place within the context
 #[derive(Debug, Clone, Copy, Default)]
 pub struct FloatedBox {
@@ -149,6 +160,16 @@ impl FloatContext {
         }
     }
 
+    pub fn find_content_slot(
+        &self,
+        min_y: f32,
+        containing_block_insets: [f32; 2],
+        clear: Clear,
+        after: Option<usize>,
+    ) -> ContentSlot {
+        self.placer.find_content_slot(min_y, containing_block_insets, clear, after)
+    }
+
     pub(crate) fn content_width(&self) -> f32 {
         match self.available_space {
             AvailableSpace::Definite(width) => width,
@@ -335,7 +356,7 @@ impl FloatPlacer {
             // segment below all existing segments. A new segment will always have space for
             // the float, so we can exit the loop at this point.
             let Some(start_segment) = self.segments.get(start_idx) else {
-                break (None, None, 0.0);
+                break (None, None, containing_block_insets[slot]);
             };
 
             // Candidate start segment doesn't have (horizontal) space for the float:
@@ -476,7 +497,56 @@ impl FloatPlacer {
         PlacedFloatedBox { width: floated_box.width, height: floated_box.height, y: start_y, x_inset: placed_inset }
     }
 
-    fn place_non_floated_content(&mut self, min_y: f32, height: f32) -> (Point<f32>, Size<f32>) {
-        todo!()
+    fn find_content_slot(
+        &self,
+        min_y: f32,
+        containing_block_insets: [f32; 2],
+        clear: Clear,
+        after: Option<usize>,
+    ) -> ContentSlot {
+        // The min starting segment index
+        let at_least = after.map(|idx| idx + 1).unwrap_or(0);
+
+        // Ensure that content respects "clear" and "after"
+        let hwm = match clear {
+            Clear::Left => {
+                let left_end = self.last_placed_floats[0].end;
+                at_least.max(left_end)
+            }
+            Clear::Right => {
+                let right_end = self.last_placed_floats[1].end;
+                at_least.max(right_end)
+            }
+            Clear::Both => {
+                let left_end = self.last_placed_floats[0].end;
+                let right_end = self.last_placed_floats[1].end;
+                at_least.max(left_end).max(right_end)
+            }
+            Clear::None => at_least,
+        };
+
+        let start_idx = self.segments[hwm..].iter().position(|segment| segment.y.end > min_y).map(|idx| idx + hwm);
+        let start_idx = start_idx.unwrap_or(self.segments.len());
+        let segment = self.segments.get(start_idx);
+        match segment {
+            Some(segment) => {
+                let inset_left = segment.insets[0].max(containing_block_insets[0]);
+                let inset_right = segment.insets[1].max(containing_block_insets[1]);
+                ContentSlot {
+                    segment_id: Some(start_idx),
+                    x: inset_left,
+                    y: segment.y.start.max(min_y),
+                    width: self.bfc_width - inset_left - inset_right,
+                    height: f32::INFINITY,
+                }
+            }
+            None => ContentSlot {
+                segment_id: None,
+                x: containing_block_insets[0],
+                y: min_y,
+                width: self.bfc_width - containing_block_insets[0] - containing_block_insets[1],
+                height: f32::INFINITY,
+            },
+        }
     }
 }
diff --git a/src/compute/mod.rs b/src/compute/mod.rs
@@ -48,7 +48,7 @@ pub use self::flexbox::compute_flexbox_layout;
 pub use self::grid::compute_grid_layout;
 
 #[cfg(feature = "float_layout")]
-pub use self::float::{FloatContext, FloatDirection, FloatedBox};
+pub use self::float::{ContentSlot, FloatContext, FloatDirection, FloatedBox};
 
 use crate::geometry::{Line, Point, Size};
 use crate::style::{AvailableSpace, CoreStyle, Overflow};
