Fix warnings and document functions

Signed-off-by: Nico Burns <[email protected]>

Author: nicoburns

src/compute/block.rs

@@ -79,19 +79,28 @@ impl BlockContext<'_> {
         }
     }
 
+    /// Set the width of the overall Block Formatting Context. This is used to resolve positions
+    /// that are relative to the right of the context such as right-floated boxes.
+    ///
+    /// Sub-blocks within a Block Formatting Context should use the `Self::sub_context` method to create
+    /// a sub-`BlockContext` with `insets` instead.
     pub fn set_width(&mut self, available_space: AvailableSpace) {
         self.bfc.float_context.set_width(available_space);
     }
 
+    /// Returns whether this block is the root block of it's Block Formatting Context
     pub fn is_bfc_root(&self) -> bool {
         self.is_root
     }
 
+    /// Set the x-axis content-box insets of the `BlockContext`. These are the difference between the border-box
+    /// and the content-box of the box (padding + border + scrollbar_gutter).
     pub fn apply_content_box_inset(&mut self, content_box_x_insets: [f32; 2]) {
         self.content_box_insets[0] = self.insets[0] + content_box_x_insets[0];
         self.content_box_insets[1] = self.insets[1] + content_box_x_insets[1];
     }
 
+    /// Position a floated box with the context
     pub fn place_floated_box(
         &mut self,
         floated_box: Size<f32>,
@@ -114,6 +123,7 @@ impl BlockContext<'_> {
         pos
     }
 
+    /// Search a space suitable for laying out non-floated content into
     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.content_box_insets, clear, after);
@@ -126,9 +136,9 @@ impl BlockContext<'_> {
         self.float_content_contribution = self.float_content_contribution.max(child_contribution);
     }
 
-    fn floated_content_width_contribution(&self) -> f32 {
-        self.bfc.float_context.content_width()
-    }
+    // fn floated_content_width_contribution(&self) -> f32 {
+    //     self.bfc.float_context.content_width()
+    // }
 
     fn floated_content_height_contribution(&self) -> f32 {
         self.float_content_contribution
@@ -200,13 +210,6 @@ struct BlockItem {
     can_be_collapsed_through: bool,
 }
 
-#[cfg(feature = "float_layout")]
-impl BlockItem {
-    fn is_floated(&self) -> bool {
-        matches!(self.float, Float::Left | Float::Right)
-    }
-}
-
 /// Computes the layout of [`LayoutPartialTree`] according to the block layout algorithm
 pub fn compute_block_layout(
     tree: &mut impl LayoutBlockContainer,

src/compute/float.rs

@@ -47,39 +47,43 @@ pub struct FloatContext {
 /// to be laid out into
 #[derive(Debug, Clone, Copy, Default)]
 pub struct ContentSlot {
+    /// The id of the segment that the slot starts in
     pub segment_id: Option<usize>,
+    /// The x position of the start of the slot
     pub x: f32,
+    /// The y position of the start of the slot
     pub y: f32,
+    /// The width of the slot
     pub width: f32,
+    /// The height of the slot
     pub height: f32,
 }
 
-/// A floated box to place within the context
-#[derive(Debug, Clone, Copy, Default)]
-pub struct FloatedBox {
-    /// A user defined ID for the box
-    // pub(crate) id: u64,
-    pub(crate) width: f32,
-    pub(crate) height: f32,
-}
+// /// A floated box to place within the context
+// #[derive(Debug, Clone, Copy, Default)]
+// pub struct FloatedBox {
+//     /// The width of the box
+//     pub(crate) width: f32,
+//     /// The height of the box
+//     pub(crate) height: f32,
+// }
 
 /// A floated box
 #[derive(Debug, Clone, Default)]
 struct PlacedFloatedBox {
     /// A user defined ID for the box
     // id: u64,
+    /// The width of the box
     width: f32,
+    /// The height of the box
     height: f32,
-    /// Distance from the edge of the container that the box is floated towards
+    /// Horizontal distance from the edge of the container that the box is floated towards
     /// (distance from the left for left floats, from the right for right floats)
     x_inset: f32,
+    /// Vertical distance from top edge of the container
     y: f32,
 }
 
-impl PlacedFloatedBox {
-    const DEFAULT: Self = Self { /*id: 0, */ width: 0.0, height: 0.0, x_inset: 0.0, y: 0.0 };
-}
-
 impl FloatContext {
     /// Create a new empty `FloatContext`
     pub fn new(available_space: AvailableSpace) -> Self {
@@ -156,6 +160,7 @@ impl FloatContext {
         }
     }
 
+    /// Search a space suitable for laying out non-floated content into
     pub fn find_content_slot(
         &self,
         min_y: f32,
@@ -166,34 +171,23 @@ impl FloatContext {
         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,
-            AvailableSpace::MinContent => {
-                let left_max =
-                    self.left_floats.iter().map(|float| float.x_inset).max_by(|a, b| a.total_cmp(b)).unwrap_or(0.0);
-                let right_max =
-                    self.right_floats.iter().map(|float| float.x_inset).max_by(|a, b| a.total_cmp(b)).unwrap_or(0.0);
-                left_max.max(right_max)
-            }
-            AvailableSpace::MaxContent => {
-                let left_max = self.left_floats.last().map(|float| float.x_inset).unwrap_or(0.0);
-                let right_max = self.right_floats.last().map(|float| float.x_inset).unwrap_or(0.0);
-                left_max + right_max
-            }
-        }
-    }
-
-    pub(crate) fn content_height(&self) -> f32 {
-        self.placer.segments.last().map(|seg| seg.y.end).unwrap_or(0.0)
-    }
-
-    fn get_float_list(&self, float_direction: FloatDirection) -> &[PlacedFloatedBox] {
-        match float_direction {
-            FloatDirection::Left => &self.left_floats,
-            FloatDirection::Right => &self.right_floats,
-        }
-    }
+    // pub(crate) fn content_width(&self) -> f32 {
+    //     match self.available_space {
+    //         AvailableSpace::Definite(width) => width,
+    //         AvailableSpace::MinContent => {
+    //             let left_max =
+    //                 self.left_floats.iter().map(|float| float.x_inset).max_by(|a, b| a.total_cmp(b)).unwrap_or(0.0);
+    //             let right_max =
+    //                 self.right_floats.iter().map(|float| float.x_inset).max_by(|a, b| a.total_cmp(b)).unwrap_or(0.0);
+    //             left_max.max(right_max)
+    //         }
+    //         AvailableSpace::MaxContent => {
+    //             let left_max = self.left_floats.last().map(|float| float.x_inset).unwrap_or(0.0);
+    //             let right_max = self.right_floats.last().map(|float| float.x_inset).unwrap_or(0.0);
+    //             left_max + right_max
+    //         }
+    //     }
+    // }
 }
 
 #[derive(Debug, Clone)]

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::{ContentSlot, FloatContext, FloatedBox};
+pub use self::float::{ContentSlot, FloatContext};
 
 use crate::geometry::{Line, Point, Size};
 use crate::style::{AvailableSpace, CoreStyle, Overflow};

src/style/float.rs

@@ -15,18 +15,26 @@ pub enum Float {
     None,
 }
 
+/// Whether a box that is definitely floated is floated to the left
+/// of to the right.
+///
+/// This type is only used in the low-level parts of the
 #[derive(Debug, Copy, Clone, PartialEq, Eq)]
 #[repr(u8)]
 pub enum FloatDirection {
+    /// The box is floated to the left
     Left = 0,
+    /// The box is floated to the right
     Right = 1,
 }
 
 impl Float {
+    /// Whether the box is floated
     pub fn is_floated(self) -> bool {
         matches!(self, Self::Left | Self::Right)
     }
 
+    /// Converts [`Float`] into `Option<FloatDirection>`ca
     pub fn float_direction(&self) -> Option<FloatDirection> {
         match self {
             Float::Left => Some(FloatDirection::Left),

src/tree/taffy_tree.rs

@@ -20,7 +20,6 @@ use crate::util::sys::{new_vec_with_capacity, ChildrenVec, Vec};
 use crate::compute::{
     compute_cached_layout, compute_hidden_layout, compute_leaf_layout, compute_root_layout, round_layout,
 };
-use crate::BlockFormattingContext;
 use crate::CacheTree;
 
 #[cfg(feature = "block_layout")]