diff --git a/components/style/gecko/conversions.rs b/components/style/gecko/conversions.rs index 8f3fb6bf2d0..5835d217ffc 100644 --- a/components/style/gecko/conversions.rs +++ b/components/style/gecko/conversions.rs @@ -810,7 +810,8 @@ impl TrackSize { if gecko_min.unit() == nsStyleUnit::eStyleUnit_None { debug_assert!(gecko_max.unit() == nsStyleUnit::eStyleUnit_Coord || - gecko_max.unit() == nsStyleUnit::eStyleUnit_Percent); + gecko_max.unit() == nsStyleUnit::eStyleUnit_Percent || + gecko_max.unit() == nsStyleUnit::eStyleUnit_Calc); return TrackSize::FitContent(LengthOrPercentage::from_gecko_style_coord(gecko_max) .expect("gecko_max could not convert to LengthOrPercentage")); } diff --git a/components/style/properties/gecko.mako.rs b/components/style/properties/gecko.mako.rs index 9a2ab2135fc..65ee7860d33 100644 --- a/components/style/properties/gecko.mako.rs +++ b/components/style/properties/gecko.mako.rs @@ -1683,6 +1683,97 @@ fn static_assert() { pub fn reset_grid_template_${kind}(&mut self, other: &Self) { self.copy_grid_template_${kind}_from(other) } + + pub fn clone_grid_template_${kind}(&self) -> longhands::grid_template_${kind}::computed_value::T { + <% self_grid = "self.gecko.mGridTemplate%s" % kind.title() %> + use Atom; + use gecko_bindings::structs::nsTArray; + use nsstring::nsStringRepr; + use values::CustomIdent; + use values::generics::grid::{GridTemplateComponent, LineNameList, RepeatCount}; + use values::generics::grid::{TrackList, TrackListType, TrackRepeat, TrackSize}; + + if ${self_grid}.mRepeatAutoLineNameListBefore.len() == 0 && + ${self_grid}.mRepeatAutoLineNameListAfter.len() == 0 && + ${self_grid}.mMinTrackSizingFunctions.len() == 0 && + ${self_grid}.mMaxTrackSizingFunctions.len() == 0 && + ${self_grid}.mLineNameLists.len() == 0 && + ${self_grid}.mRepeatAutoIndex == -1 && + !${self_grid}.mIsAutoFill() && + !${self_grid}.mIsSubgrid() { + return GridTemplateComponent::None; + } + + #[inline] + fn to_boxed_customident_slice(gecko_names: &nsTArray) -> Box<[CustomIdent]> { + let idents: Vec = gecko_names.iter().map(|gecko_name| { + CustomIdent(Atom::from(gecko_name.to_string())) + }).collect(); + idents.into_boxed_slice() + } + + #[inline] + fn to_line_names_vec(gecko_line_names: &nsTArray>) + -> Vec> { + gecko_line_names.iter().map(|gecko_names| { + to_boxed_customident_slice(gecko_names) + }).collect() + } + + let repeat_auto_index = ${self_grid}.mRepeatAutoIndex as usize; + if ${self_grid}.mIsSubgrid() { + let mut names_vec = to_line_names_vec(&${self_grid}.mLineNameLists); + let fill_idx = if ${self_grid}.mIsAutoFill() { + names_vec.insert( + repeat_auto_index, + to_boxed_customident_slice(&${self_grid}.mRepeatAutoLineNameListBefore)); + Some(repeat_auto_index as u32) + } else { + None + }; + let names = names_vec.into_boxed_slice(); + + GridTemplateComponent::Subgrid(LineNameList{names, fill_idx}) + } else { + let mut auto_repeat = None; + let mut list_type = TrackListType::Normal; + let line_names = to_line_names_vec(&${self_grid}.mLineNameLists).into_boxed_slice(); + let mut values = Vec::with_capacity(${self_grid}.mMinTrackSizingFunctions.len()); + + let min_max_iter = ${self_grid}.mMinTrackSizingFunctions.iter() + .zip(${self_grid}.mMaxTrackSizingFunctions.iter()); + for (i, (gecko_min, gecko_max)) in min_max_iter.enumerate() { + let track_size = TrackSize::from_gecko_style_coords(gecko_min, gecko_max); + + if i == repeat_auto_index { + list_type = TrackListType::Auto(repeat_auto_index as u16); + + let count = if ${self_grid}.mIsAutoFill() { + RepeatCount::AutoFill + } else { + RepeatCount::AutoFit + }; + + let line_names = { + let mut vec: Vec> = Vec::with_capacity(2); + vec.push(to_boxed_customident_slice( + &${self_grid}.mRepeatAutoLineNameListBefore)); + vec.push(to_boxed_customident_slice( + &${self_grid}.mRepeatAutoLineNameListAfter)); + vec.into_boxed_slice() + }; + + let track_sizes = vec!(track_size); + + auto_repeat = Some(TrackRepeat{count, line_names, track_sizes}); + } else { + values.push(track_size); + } + } + + GridTemplateComponent::TrackList(TrackList{list_type, values, line_names, auto_repeat}) + } + } % endfor ${impl_simple_type_with_conversion("grid_auto_flow")} @@ -1726,6 +1817,49 @@ fn static_assert() { pub fn reset_grid_template_areas(&mut self, other: &Self) { self.copy_grid_template_areas_from(other) } + + pub fn clone_grid_template_areas(&self) -> longhands::grid_template_areas::computed_value::T { + use properties::longhands::grid_template_areas::{NamedArea, TemplateAreas}; + use std::ops::Range; + use values::None_; + + if self.gecko.mGridTemplateAreas.mRawPtr.is_null() { + return Either::Second(None_); + } + + let gecko_grid_template_areas = self.gecko.mGridTemplateAreas.mRawPtr; + let areas = unsafe { + let vec: Vec = + (*gecko_grid_template_areas).mNamedAreas.iter().map(|gecko_name_area| { + let name = gecko_name_area.mName.to_string().into_boxed_str(); + let rows = Range { + start: gecko_name_area.mRowStart, + end: gecko_name_area.mRowEnd + }; + let columns = Range { + start: gecko_name_area.mColumnStart, + end: gecko_name_area.mColumnEnd + }; + NamedArea{ name, rows, columns } + }).collect(); + vec.into_boxed_slice() + }; + + let strings = unsafe { + let vec: Vec> = + (*gecko_grid_template_areas).mTemplates.iter().map(|gecko_template| { + gecko_template.to_string().into_boxed_str() + }).collect(); + vec.into_boxed_slice() + }; + + let width = unsafe { + (*gecko_grid_template_areas).mNColumns + }; + + Either::First(TemplateAreas{ areas, strings, width }) + } + <% skip_outline_longhands = " ".join("outline-style outline-width".split() + diff --git a/components/style/properties/longhand/position.mako.rs b/components/style/properties/longhand/position.mako.rs index 780b7ebabca..dd1cb9d5724 100644 --- a/components/style/properties/longhand/position.mako.rs +++ b/components/style/properties/longhand/position.mako.rs @@ -282,7 +282,7 @@ ${helpers.predefined_type("object-position", products="gecko", spec="https://drafts.csswg.org/css-grid/#propdef-grid-template-%ss" % kind, boxed=True, - animation_value_type="none")} + animation_value_type="discrete")} % endfor @@ -416,7 +416,7 @@ ${helpers.predefined_type("object-position", <%helpers:longhand name="grid-template-areas" spec="https://drafts.csswg.org/css-grid/#propdef-grid-template-areas" products="gecko" - animation_value_type="none" + animation_value_type="discrete" disable_when_testing="True" boxed="True"> use std::collections::HashMap; @@ -442,14 +442,14 @@ ${helpers.predefined_type("object-position", SpecifiedValue::parse(context, input) } - #[derive(Clone, PartialEq)] + #[derive(Clone, Debug, PartialEq)] pub struct TemplateAreas { pub areas: Box<[NamedArea]>, pub strings: Box<[Box]>, pub width: u32, } - #[derive(Clone, PartialEq)] + #[derive(Clone, Debug, PartialEq)] pub struct NamedArea { pub name: Box, pub rows: Range,