Named grid lines and areas WIP

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

Author: nicoburns

Cargo.toml

@@ -39,6 +39,7 @@ default = [
     "taffy_tree",
     "flexbox",
     "grid",
+    "grid_named",
     "block_layout",
     "calc",
     "content_size",
@@ -54,6 +55,8 @@ block_layout = []
 flexbox = []
 ## Enables the CSS Grid layout algorithm. See [`compute_grid_layout`](crate::compute_grid_layout).
 grid = ["alloc", "dep:grid"]
+## Enables names grid lines and areas for the grid layout algorithm
+grid_named = ["grid"]
 ## Enables calc() values for all layout algorithms
 calc = []
 ## Causes all algorithms to compute and output a content size for each node

src/compute/grid/explicit_grid.rs

@@ -13,6 +13,7 @@ use crate::{GridContainerStyle, MaybeResolve};
 pub(crate) fn compute_explicit_grid_size_in_axis(
     style: &impl GridContainerStyle,
     template: &[TrackSizingFunction],
+    grid_area_track_count: u16,
     inner_container_size: Size<Option<f32>>,
     resolve_calc_value: impl Fn(*const (), f32) -> f32,
     axis: AbsoluteAxis,
@@ -174,7 +175,8 @@ pub(crate) fn compute_explicit_grid_size_in_axis(
         }
     };
 
-    non_auto_repeating_track_count + (repetition_track_count * num_repetitions)
+    let grid_template_track_count = non_auto_repeating_track_count + (repetition_track_count * num_repetitions);
+    (grid_template_track_count).max(grid_area_track_count)
 }
 
 /// Resolve the track sizing functions of explicit tracks, automatically created tracks, and gutters

src/compute/grid/implicit_grid.rs

@@ -2,7 +2,7 @@
 //! to reduce the number of allocations required when creating a grid.
 use crate::geometry::Line;
 use crate::style::{GenericGridPlacement, GridPlacement};
-use crate::GridItemStyle;
+use crate::{CheapCloneStr, GridItemStyle};
 use core::cmp::{max, min};
 
 use super::types::TrackCounts;
@@ -91,8 +91,8 @@ fn get_known_child_positions<'a, S: GridItemStyle + 'a>(
 ///
 /// Values are returned in origin-zero coordinates
 #[inline]
-fn child_min_line_max_line_span(
-    line: Line<GridPlacement>,
+fn child_min_line_max_line_span<S: CheapCloneStr>(
+    line: Line<GridPlacement<S>>,
     explicit_track_count: u16,
 ) -> (OriginZeroLine, OriginZeroLine, u16) {
     use GenericGridPlacement::*;
@@ -104,7 +104,8 @@ fn child_min_line_max_line_span(
     // D. If the placement contains only a span for a named line, replace it with a span of 1.
 
     // Convert line into origin-zero coordinates before attempting to analyze
-    let oz_line = line.into_origin_zero(explicit_track_count);
+    // We ignore named lines here as they are accounted for separately
+    let oz_line = line.into_origin_zero_ignoring_named(explicit_track_count);
 
     let min = match (oz_line.start, oz_line.end) {
         // Both tracks specified
@@ -156,8 +157,8 @@ fn child_min_line_max_line_span(
 
     // Calculate span only for indefinitely placed items as we don't need for other items (whose required space will
     // be taken into account by min and max)
-    let span = match (line.start, line.end) {
-        (Auto | Span(_), Auto | Span(_)) => line.indefinite_span(),
+    let span = match (oz_line.start, oz_line.end) {
+        (Auto | Span(_), Auto | Span(_)) => oz_line.indefinite_span(),
         _ => 1,
     };
 

src/compute/grid/mod.rs

@@ -12,7 +12,7 @@ use crate::util::MaybeMath;
 use crate::util::{MaybeResolve, ResolveOrZero};
 use crate::{
     style_helpers::*, AlignContent, BoxGenerationMode, BoxSizing, CoreStyle, GridContainerStyle, GridItemStyle,
-    JustifyContent, LayoutGridContainer,
+    JustifyContent, LayoutGridContainer, LayoutPartialTree,
 };
 use alignment::{align_and_position_item, align_tracks};
 use explicit_grid::{compute_explicit_grid_size_in_axis, initialize_grid_tracks};
@@ -21,7 +21,7 @@ use placement::place_grid_items;
 use track_sizing::{
     determine_if_item_crosses_flexible_or_intrinsic_tracks, resolve_item_track_indexes, track_sizing_algorithm,
 };
-use types::{CellOccupancyMatrix, GridTrack};
+use types::{CellOccupancyMatrix, GridTrack, NamedLineResolver};
 
 #[cfg(feature = "detailed_layout_info")]
 use types::{GridItem, GridTrackKind, TrackCounts};
@@ -105,6 +105,13 @@ pub fn compute_grid_layout<Tree: LayoutGridContainer>(
     let grid_auto_columms = style.grid_auto_columns();
     let grid_auto_rows = style.grid_auto_rows();
 
+    // type CustomIdent<'a> = <<Tree as LayoutGridContainer>::GridContainerStyle<'a> as GridContainerStyle>::CustomIdent;
+    let name_resolver = NamedLineResolver::<
+        <<Tree as LayoutPartialTree>::CoreContainerStyle<'_> as CoreStyle>::CustomIdent,
+    >::new(style.grid_template_areas());
+    let grid_area_column_count = name_resolver.area_column_count();
+    let grid_area_row_count = name_resolver.area_row_count();
+
     let constrained_available_space = known_dimensions
         .or(preferred_size)
         .map(|size| size.map(AvailableSpace::Definite))
@@ -156,13 +163,15 @@ pub fn compute_grid_layout<Tree: LayoutGridContainer>(
     let explicit_col_count = compute_explicit_grid_size_in_axis(
         &style,
         grid_template_columms.borrow(),
+        grid_area_column_count,
         auto_fit_container_size,
         |val, basis| tree.calc(val, basis),
         AbsoluteAxis::Horizontal,
     );
     let explicit_row_count = compute_explicit_grid_size_in_axis(
         &style,
         grid_template_rows.borrow(),
+        grid_area_row_count,
         auto_fit_container_size,
         |val, basis| tree.calc(val, basis),
         AbsoluteAxis::Vertical,
@@ -193,6 +202,7 @@ pub fn compute_grid_layout<Tree: LayoutGridContainer>(
         style.grid_auto_flow(),
         align_items.unwrap_or(AlignItems::Stretch),
         justify_items.unwrap_or(AlignItems::Stretch),
+        &name_resolver,
     );
 
     // Extract track counts from previous step (auto-placement can expand the number of tracks)
@@ -541,17 +551,17 @@ pub fn compute_grid_layout<Tree: LayoutGridContainer>(
         if child_style.position() == Position::Absolute {
             // Convert grid-col-{start/end} into Option's of indexes into the columns vector
             // The Option is None if the style property is Auto and an unresolvable Span
-            let maybe_col_indexes = child_style
-                .grid_column()
+            let maybe_col_indexes = name_resolver
+                .resolve_column_names(&child_style.grid_column())
                 .into_origin_zero(final_col_counts.explicit)
                 .resolve_absolutely_positioned_grid_tracks()
                 .map(|maybe_grid_line| {
                     maybe_grid_line.map(|line: OriginZeroLine| line.into_track_vec_index(final_col_counts))
                 });
             // Convert grid-row-{start/end} into Option's of indexes into the row vector
             // The Option is None if the style property is Auto and an unresolvable Span
-            let maybe_row_indexes = child_style
-                .grid_row()
+            let maybe_row_indexes = name_resolver
+                .resolve_row_names(&child_style.grid_row())
                 .into_origin_zero(final_row_counts.explicit)
                 .resolve_absolutely_positioned_grid_tracks()
                 .map(|maybe_grid_line| {

src/compute/grid/placement.rs

@@ -1,13 +1,13 @@
 //! Implements placing items in the grid and resolving the implicit grid.
 //! <https://www.w3.org/TR/css-grid-1/#placement>
 use super::types::{CellOccupancyMatrix, CellOccupancyState, GridItem};
-use super::OriginZeroLine;
+use super::{NamedLineResolver, OriginZeroLine};
 use crate::geometry::Line;
 use crate::geometry::{AbsoluteAxis, InBothAbsAxis};
 use crate::style::{AlignItems, GridAutoFlow, OriginZeroGridPlacement};
 use crate::tree::NodeId;
 use crate::util::sys::Vec;
-use crate::GridItemStyle;
+use crate::{CoreStyle, GridItemStyle};
 
 /// 8.5. Grid Item Placement Algorithm
 /// Place items into the grid, generating new rows/column into the implicit grid as required
@@ -20,6 +20,7 @@ pub(super) fn place_grid_items<'a, S, ChildIter>(
     grid_auto_flow: GridAutoFlow,
     align_items: AlignItems,
     justify_items: AlignItems,
+    named_line_resolver: &NamedLineResolver<<S as CoreStyle>::CustomIdent>,
 ) where
     S: GridItemStyle + 'a,
     ChildIter: Iterator<Item = (usize, NodeId, S)>,
@@ -32,10 +33,12 @@ pub(super) fn place_grid_items<'a, S, ChildIter>(
         let explicit_row_count = cell_occupancy_matrix.track_counts(AbsoluteAxis::Vertical).explicit;
         move |(index, node, style): (usize, NodeId, S)| -> (_, _, _, S) {
             let origin_zero_placement = InBothAbsAxis {
-                horizontal: style
-                    .grid_column()
+                horizontal: named_line_resolver
+                    .resolve_column_names(&style.grid_column())
                     .map(|placement| placement.into_origin_zero_placement(explicit_col_count)),
-                vertical: style.grid_row().map(|placement| placement.into_origin_zero_placement(explicit_row_count)),
+                vertical: named_line_resolver
+                    .resolve_row_names(&style.grid_row())
+                    .map(|placement| placement.into_origin_zero_placement(explicit_row_count)),
             };
             (index, node, origin_zero_placement, style)
         }

src/compute/grid/types/mod.rs

@@ -4,6 +4,7 @@ mod coordinates;
 mod grid_item;
 mod grid_track;
 mod grid_track_counts;
+mod named;
 
 // Publish only locally in the grid module
 pub(super) use cell_occupancy::{CellOccupancyMatrix, CellOccupancyState};
@@ -15,6 +16,8 @@ pub(super) use grid_track_counts::TrackCounts;
 #[allow(unused_imports)]
 pub(super) use grid_track::GridTrackKind;
 
+pub(super) use named::NamedLineResolver;
+
 // pub(super) enum GridPosition {
 //     Auto,
 //     LineIndex(i16),

src/compute/grid/types/named.rs

@@ -0,0 +1,122 @@
+use crate::{
+    CheapCloneStr, GenericGridPlacement, GridAreaAxis, GridAreaEnd, GridPlacement, GridTemplateArea, Line,
+    NonNamedGridPlacement,
+};
+use core::borrow::Borrow;
+use std::{
+    collections::HashMap,
+    hash::{Hash, Hasher},
+};
+
+/// Wrap an `AsRef<str>` type with a type which implements Hash by first
+/// deferring to the underlying `&str`'s implementation of Hash.
+#[derive(Debug, Clone)]
+pub(crate) struct StrHasher<T: CheapCloneStr>(pub T);
+impl<T: CheapCloneStr> Hash for StrHasher<T> {
+    fn hash<H: Hasher>(&self, state: &mut H) {
+        // Dele
+        self.0.as_ref().hash(state)
+    }
+}
+impl<T: CheapCloneStr> PartialEq for StrHasher<T> {
+    fn eq(&self, other: &Self) -> bool {
+        other.0.as_ref() == self.0.as_ref()
+    }
+}
+impl<T: CheapCloneStr> Borrow<str> for StrHasher<T> {
+    fn borrow(&self) -> &str {
+        self.0.as_ref()
+    }
+}
+impl<T: CheapCloneStr> Eq for StrHasher<T> {}
+
+/// Resolve lines for
+pub(crate) struct NamedLineResolver<S: CheapCloneStr> {
+    lines: HashMap<StrHasher<S>, i16>,
+    areas: HashMap<StrHasher<S>, GridTemplateArea<S>>,
+    area_column_count: u16,
+    area_row_count: u16,
+}
+
+impl<S: CheapCloneStr> NamedLineResolver<S> {
+    pub(crate) fn new(area_styles: Option<impl Borrow<[GridTemplateArea<S>]>>) -> Self {
+        let mut area_column_count = 0;
+        let mut area_row_count = 0;
+        let mut areas: HashMap<StrHasher<_>, GridTemplateArea<_>> = HashMap::new();
+        if let Some(area_iter) = area_styles {
+            for area in area_iter.borrow() {
+                // TODO: Investigate eliminating clones
+                areas.insert(StrHasher(area.name.clone()), area.clone());
+
+                area_column_count = area_column_count.max(area.column_end);
+                area_row_count = area_row_count.max(area.row_end);
+            }
+        }
+
+        Self { area_column_count, area_row_count, areas, lines: HashMap::new() }
+    }
+
+    #[inline(always)]
+    pub(crate) fn resolve_row_names(&self, line: &Line<GridPlacement<S>>) -> Line<NonNamedGridPlacement> {
+        self.resolve_line_names(line, GridAreaAxis::Row)
+    }
+
+    #[inline(always)]
+    pub(crate) fn resolve_column_names(&self, line: &Line<GridPlacement<S>>) -> Line<NonNamedGridPlacement> {
+        self.resolve_line_names(line, GridAreaAxis::Column)
+    }
+
+    #[inline(always)]
+    pub(crate) fn resolve_line_names(
+        &self,
+        line: &Line<GridPlacement<S>>,
+        axis: GridAreaAxis,
+    ) -> Line<NonNamedGridPlacement> {
+        Line {
+            start: self.resolve_line_name(&line.start, axis, GridAreaEnd::Start),
+            end: self.resolve_line_name(&line.end, axis, GridAreaEnd::End),
+        }
+    }
+
+    pub(crate) fn resolve_line_name(
+        &self,
+        placement: &GridPlacement<S>,
+        axis: GridAreaAxis,
+        end: GridAreaEnd,
+    ) -> NonNamedGridPlacement {
+        match placement {
+            GridPlacement::Auto => NonNamedGridPlacement::Auto,
+            GridPlacement::Line(grid_line) => NonNamedGridPlacement::Line(*grid_line),
+            GridPlacement::Span(span) => NonNamedGridPlacement::Span(*span),
+            GridPlacement::Named(name) => {
+                let name = name.as_ref();
+                if name.ends_with("-start") {
+                    let area_name = &name[0..(name.len() - 6)];
+                    if let Some(area) = self.areas.get(area_name) {
+                        return GenericGridPlacement::Line(area.get_side(axis, GridAreaEnd::Start));
+                    }
+                } else if name.ends_with("-end") {
+                    let area_name = &name[0..(name.len() - 6)];
+                    if let Some(area) = self.areas.get(area_name) {
+                        return GenericGridPlacement::Line(area.get_side(axis, GridAreaEnd::End));
+                    }
+                } else {
+                    if let Some(area) = self.areas.get(name) {
+                        return GenericGridPlacement::Line(area.get_side(axis, end));
+                    }
+                }
+
+                // TODO: lookup names lines
+                NonNamedGridPlacement::Auto
+            }
+        }
+    }
+
+    pub(crate) fn area_column_count(&self) -> u16 {
+        self.area_column_count
+    }
+
+    pub(crate) fn area_row_count(&self) -> u16 {
+        self.area_row_count
+    }
+}