diff --git a/components/style/properties/longhand/position.mako.rs b/components/style/properties/longhand/position.mako.rs index 013b93b2640..1dc697bd201 100644 --- a/components/style/properties/longhand/position.mako.rs +++ b/components/style/properties/longhand/position.mako.rs @@ -69,8 +69,8 @@ ${helpers.single_keyword("flex-wrap", "nowrap wrap wrap-reverse", animation_value_type="discrete")} % else: ${helpers.predefined_type(name="justify-content", - type="ContentDistribution", - initial_value="specified::ContentDistribution::normal()", + type="JustifyContent", + initial_value="specified::JustifyContent(specified::ContentDistribution::normal())", spec="https://drafts.csswg.org/css-align/#propdef-justify-content", extra_prefixes="webkit", animation_value_type="discrete")} @@ -90,8 +90,8 @@ ${helpers.single_keyword("flex-wrap", "nowrap wrap wrap-reverse", animation_value_type="discrete")} % else: ${helpers.predefined_type(name="align-content", - type="ContentDistribution", - initial_value="specified::ContentDistribution::normal()", + type="AlignContent", + initial_value="specified::AlignContent(specified::ContentDistribution::normal())", spec="https://drafts.csswg.org/css-align/#propdef-align-content", extra_prefixes="webkit", animation_value_type="discrete")} @@ -138,15 +138,15 @@ ${helpers.predefined_type("flex-shrink", "NonNegativeNumber", animation_value_type="discrete")} % else: ${helpers.predefined_type(name="align-self", - type="SelfAlignment", - initial_value="specified::SelfAlignment::auto()", + type="AlignSelf", + initial_value="specified::AlignSelf(specified::SelfAlignment::auto())", spec="https://drafts.csswg.org/css-align/#align-self-property", extra_prefixes="webkit", animation_value_type="discrete")} ${helpers.predefined_type(name="justify-self", - type="SelfAlignment", - initial_value="specified::SelfAlignment::auto()", + type="JustifySelf", + initial_value="specified::JustifySelf(specified::SelfAlignment::auto())", spec="https://drafts.csswg.org/css-align/#justify-self-property", animation_value_type="discrete")} diff --git a/components/style/properties/shorthand/position.mako.rs b/components/style/properties/shorthand/position.mako.rs index 8775eed5c2c..340fdaddbce 100644 --- a/components/style/properties/shorthand/position.mako.rs +++ b/components/style/properties/shorthand/position.mako.rs @@ -615,33 +615,44 @@ <%helpers:shorthand name="place-content" sub_properties="align-content justify-content" spec="https://drafts.csswg.org/css-align/#propdef-place-content" products="gecko"> - use values::specified::align::{ContentDistribution, FallbackAllowed}; + use values::specified::align::{AlignContent, JustifyContent, ContentDistribution, AxisDirection}; pub fn parse_value<'i, 't>( _: &ParserContext, input: &mut Parser<'i, 't>, ) -> Result> { - let align = ContentDistribution::parse_with_fallback(input, FallbackAllowed::No)?; - if align.has_extra_flags() { - return Err(input.new_custom_error(StyleParseErrorKind::UnspecifiedError)); - } - let justify = - input.try(|input| ContentDistribution::parse_with_fallback(input, FallbackAllowed::No)) - .unwrap_or(align); - if justify.has_extra_flags() { + let align_content = + ContentDistribution::parse(input, AxisDirection::Block)?; + + let justify_content = input.try(|input| { + ContentDistribution::parse(input, AxisDirection::Inline) + }); + + let justify_content = match justify_content { + Ok(v) => v, + Err(err) => { + if !align_content.is_valid_on_both_axes() { + return Err(err); + } + + align_content + } + }; + + if align_content.has_extra_flags() || justify_content.has_extra_flags() { return Err(input.new_custom_error(StyleParseErrorKind::UnspecifiedError)); } Ok(expanded! { - align_content: align, - justify_content: justify, + align_content: AlignContent(align_content), + justify_content: JustifyContent(justify_content), }) } impl<'a> ToCss for LonghandsToSerialize<'a> { fn to_css(&self, dest: &mut CssWriter) -> fmt::Result where W: fmt::Write { self.align_content.to_css(dest)?; - if self.align_content != self.justify_content { + if self.align_content.0 != self.justify_content.0 { dest.write_str(" ")?; self.justify_content.to_css(dest)?; } @@ -653,35 +664,43 @@ <%helpers:shorthand name="place-self" sub_properties="align-self justify-self" spec="https://drafts.csswg.org/css-align/#place-self-property" products="gecko"> - use values::specified::align::SelfAlignment; - use parser::Parse; + use values::specified::align::{AlignSelf, JustifySelf, SelfAlignment, AxisDirection}; - pub fn parse_value<'i, 't>(context: &ParserContext, input: &mut Parser<'i, 't>) - -> Result> { - let align = SelfAlignment::parse(context, input)?; - if align.has_extra_flags() { - return Err(input.new_custom_error(StyleParseErrorKind::UnspecifiedError)); - } - let justify = input.try(|input| SelfAlignment::parse(context, input)).unwrap_or(align.clone()); - if justify.has_extra_flags() { + pub fn parse_value<'i, 't>( + _: &ParserContext, + input: &mut Parser<'i, 't>, + ) -> Result> { + let align = SelfAlignment::parse(input, AxisDirection::Block)?; + let justify = input.try(|input| SelfAlignment::parse(input, AxisDirection::Inline)); + + let justify = match justify { + Ok(v) => v, + Err(err) => { + if !align.is_valid_on_both_axes() { + return Err(err); + } + align + } + }; + + if justify.has_extra_flags() || align.has_extra_flags() { return Err(input.new_custom_error(StyleParseErrorKind::UnspecifiedError)); } Ok(expanded! { - align_self: align, - justify_self: justify, + align_self: AlignSelf(align), + justify_self: JustifySelf(justify), }) } impl<'a> ToCss for LonghandsToSerialize<'a> { fn to_css(&self, dest: &mut CssWriter) -> fmt::Result where W: fmt::Write { - if self.align_self == self.justify_self { - self.align_self.to_css(dest) - } else { - self.align_self.to_css(dest)?; + self.align_self.to_css(dest)?; + if self.align_self.0 != self.justify_self.0 { dest.write_str(" ")?; - self.justify_self.to_css(dest) + self.justify_self.to_css(dest)?; } + Ok(()) } } diff --git a/components/style/values/computed/align.rs b/components/style/values/computed/align.rs index c7bf6a30c6b..02a93ee6f5d 100644 --- a/components/style/values/computed/align.rs +++ b/components/style/values/computed/align.rs @@ -11,7 +11,8 @@ use style_traits::{CssWriter, ToCss}; use values::computed::{Context, ToComputedValue}; use values::specified; -pub use super::specified::{AlignItems, ContentDistribution, SelfAlignment}; +pub use super::specified::{AlignContent, JustifyContent, AlignItems, SelfAlignment}; +pub use super::specified::{AlignSelf, JustifySelf}; /// The computed value for the `justify-items` property. /// diff --git a/components/style/values/computed/mod.rs b/components/style/values/computed/mod.rs index 7600d23a9d1..4156e784c9e 100644 --- a/components/style/values/computed/mod.rs +++ b/components/style/values/computed/mod.rs @@ -32,7 +32,9 @@ use super::specified; pub use app_units::Au; pub use properties::animated_properties::TransitionProperty; #[cfg(feature = "gecko")] -pub use self::align::{AlignItems, ContentDistribution, SelfAlignment, JustifyItems}; +pub use self::align::{AlignItems, AlignContent, JustifyContent, SelfAlignment, JustifyItems}; +#[cfg(feature = "gecko")] +pub use self::align::{AlignSelf, JustifySelf}; pub use self::angle::Angle; pub use self::background::{BackgroundSize, BackgroundRepeat}; pub use self::border::{BorderImageSlice, BorderImageWidth, BorderImageSideWidth}; diff --git a/components/style/values/specified/align.rs b/components/style/values/specified/align.rs index 584a24b61fb..9e8d49dfe00 100644 --- a/components/style/values/specified/align.rs +++ b/components/style/values/specified/align.rs @@ -18,8 +18,7 @@ bitflags! { /// Constants shared by multiple CSS Box Alignment properties /// /// These constants match Gecko's `NS_STYLE_ALIGN_*` constants. - #[cfg_attr(feature = "gecko", derive(MallocSizeOf))] - #[derive(ToComputedValue)] + #[derive(MallocSizeOf, ToComputedValue)] pub struct AlignFlags: u8 { // Enumeration stored in the lower 5 bits: /// 'auto' @@ -70,12 +69,27 @@ bitflags! { } } +impl AlignFlags { + /// Returns the enumeration value stored in the lower 5 bits. + #[inline] + fn value(&self) -> Self { + *self & !AlignFlags::FLAG_BITS + } +} + impl ToCss for AlignFlags { fn to_css(&self, dest: &mut CssWriter) -> fmt::Result where W: Write, { - let s = match *self & !AlignFlags::FLAG_BITS { + match *self & AlignFlags::FLAG_BITS { + AlignFlags::LEGACY => dest.write_str("legacy ")?, + AlignFlags::SAFE => dest.write_str("safe ")?, + // Don't serialize "unsafe", since it's the default. + _ => {} + } + + dest.write_str(match self.value() { AlignFlags::AUTO => "auto", AlignFlags::NORMAL => "normal", AlignFlags::START => "start", @@ -94,46 +108,29 @@ impl ToCss for AlignFlags { AlignFlags::SPACE_AROUND => "space-around", AlignFlags::SPACE_EVENLY => "space-evenly", _ => unreachable!() - }; - dest.write_str(s)?; - - match *self & AlignFlags::FLAG_BITS { - AlignFlags::LEGACY => { dest.write_str(" legacy")?; } - AlignFlags::SAFE => { dest.write_str(" safe")?; } - AlignFlags::UNSAFE => { dest.write_str(" unsafe")?; } - _ => {} - } - Ok(()) + }) } } -/// Mask for a single AlignFlags value. -const ALIGN_ALL_BITS: u16 = structs::NS_STYLE_ALIGN_ALL_BITS as u16; -/// Number of bits to shift a fallback alignment. -const ALIGN_ALL_SHIFT: u32 = structs::NS_STYLE_ALIGN_ALL_SHIFT; +/// An axis direction, either inline (for the `justify` properties) or block, +/// (for the `align` properties). +#[derive(Clone, Copy, PartialEq)] +pub enum AxisDirection { + /// Block direction. + Block, + /// Inline direction. + Inline, +} -/// Value of the `align-content` or `justify-content` property. +/// Shared value for the `align-content` and `justify-content` properties. /// /// -#[derive(Clone, Copy, Debug, Eq, MallocSizeOf, PartialEq, ToComputedValue)] +#[derive(Clone, Copy, Debug, Eq, MallocSizeOf, PartialEq, ToComputedValue, ToCss)] #[cfg_attr(feature = "servo", derive(Deserialize, Serialize))] pub struct ContentDistribution { primary: AlignFlags, - fallback: AlignFlags, -} - -/// Whether fallback is allowed in align-content / justify-content parsing. -/// -/// This is used for the place-content shorthand, until the resolutions from [1] -/// are specified. -/// -/// [1]: https://github.com/w3c/csswg-drafts/issues/1002 -#[derive(Clone, Copy, PartialEq)] -pub enum FallbackAllowed { - /// Allow fallback alignment. - Yes, - /// Don't allow fallback alignment. - No, + // FIXME(https://github.com/w3c/csswg-drafts/issues/1002): This will need to + // accept fallback alignment, eventually. } impl ContentDistribution { @@ -143,18 +140,35 @@ impl ContentDistribution { Self::new(AlignFlags::NORMAL) } - /// Construct a value with no fallback. + /// The initial value 'normal' #[inline] - pub fn new(flags: AlignFlags) -> Self { - Self::with_fallback(flags, AlignFlags::empty()) + pub fn new(primary: AlignFlags) -> Self { + Self { primary } } - /// Construct a value including a fallback alignment. - /// - /// - #[inline] - pub fn with_fallback(primary: AlignFlags, fallback: AlignFlags) -> Self { - Self { primary, fallback } + fn from_bits(bits: u16) -> Self { + Self { + primary: AlignFlags::from_bits_truncate(bits as u8) + } + } + + fn as_bits(&self) -> u16 { + self.primary.bits() as u16 + } + + /// Returns whether this value is valid for both axis directions. + pub fn is_valid_on_both_axes(&self) -> bool { + match self.primary.value() { + // is only allowed on the block axis. + AlignFlags::BASELINE | + AlignFlags::LAST_BASELINE => false, + + // left | right are only allowed on the inline axis. + AlignFlags::LEFT | + AlignFlags::RIGHT => false, + + _ => true, + } } /// The primary alignment @@ -163,83 +177,119 @@ impl ContentDistribution { self.primary } - /// The fallback alignment - #[inline] - pub fn fallback(self) -> AlignFlags { - self.fallback - } - /// Whether this value has extra flags. #[inline] pub fn has_extra_flags(self) -> bool { - self.primary().intersects(AlignFlags::FLAG_BITS) || - self.fallback().intersects(AlignFlags::FLAG_BITS) + self.primary().intersects(AlignFlags::FLAG_BITS) } - /// Parse a value for align-content / justify-content, optionally allowing - /// fallback. - pub fn parse_with_fallback<'i, 't>( + /// Parse a value for align-content / justify-content. + pub fn parse<'i, 't>( input: &mut Parser<'i, 't>, - fallback_allowed: FallbackAllowed, + axis: AxisDirection, ) -> Result> { - // normal | - if let Ok(value) = input.try(|input| parse_normal_or_baseline(input)) { - return Ok(ContentDistribution::new(value)) + // Try to parse normal first + if input.try(|i| i.expect_ident_matching("normal")).is_ok() { + return Ok(ContentDistribution::normal()); } - // followed by optional <*-position> - if let Ok(value) = input.try(|input| parse_content_distribution(input)) { - if fallback_allowed == FallbackAllowed::Yes { - if let Ok(fallback) = input.try(|input| parse_overflow_content_position(input)) { - return Ok(ContentDistribution::with_fallback(value, fallback)) - } - } - return Ok(ContentDistribution::new(value)) - } - - // <*-position> followed by optional - let fallback = parse_overflow_content_position(input)?; - if fallback_allowed == FallbackAllowed::Yes { - if let Ok(value) = input.try(|input| parse_content_distribution(input)) { - return Ok(ContentDistribution::with_fallback(value, fallback)) + // Parse , but only on the block axis. + if axis == AxisDirection::Block { + if let Ok(value) = input.try(parse_baseline) { + return Ok(ContentDistribution::new(value)); } } - Ok(ContentDistribution::new(fallback)) - } -} - -impl ToCss for ContentDistribution { - fn to_css(&self, dest: &mut CssWriter) -> fmt::Result - where - W: Write, - { - self.primary().to_css(dest)?; - match self.fallback() { - AlignFlags::AUTO => {} - fallback => { - dest.write_str(" ")?; - fallback.to_css(dest)?; - } + // + if let Ok(value) = input.try(parse_content_distribution) { + return Ok(ContentDistribution::new(value)); } - Ok(()) + + // ? + let overflow_position = + input.try(parse_overflow_position) + .unwrap_or(AlignFlags::empty()); + + let content_position = try_match_ident_ignore_ascii_case! { input, + "start" => AlignFlags::START, + "end" => AlignFlags::END, + "flex-start" => AlignFlags::FLEX_START, + "flex-end" => AlignFlags::FLEX_END, + "center" => AlignFlags::CENTER, + "left" if axis == AxisDirection::Inline => AlignFlags::LEFT, + "right" if axis == AxisDirection::Inline => AlignFlags::RIGHT, + }; + + Ok(ContentDistribution::new(content_position | overflow_position)) } } - -impl Parse for ContentDistribution { - // normal | | - // [ || [ ? && ] ] - fn parse<'i, 't>(_: &ParserContext, input: &mut Parser<'i, 't>) -> Result> { - Self::parse_with_fallback(input, FallbackAllowed::Yes) - } -} - -/// Value of the `align-self` or `justify-self` property. +/// Value for the `align-content` property. /// +/// +#[derive(Clone, Copy, Debug, Eq, MallocSizeOf, PartialEq, ToComputedValue, ToCss)] +pub struct AlignContent(pub ContentDistribution); + +impl Parse for AlignContent { + fn parse<'i, 't>( + _: &ParserContext, + input: &mut Parser<'i, 't>, + ) -> Result> { + Ok(AlignContent(ContentDistribution::parse( + input, + AxisDirection::Block, + )?)) + } +} + +#[cfg(feature = "gecko")] +impl From for AlignContent { + fn from(bits: u16) -> Self { + AlignContent(ContentDistribution::from_bits(bits)) + } +} + +#[cfg(feature = "gecko")] +impl From for u16 { + fn from(v: AlignContent) -> u16 { + v.0.as_bits() + } +} + +/// Value for the `justify-content` property. +/// +/// +#[derive(Clone, Copy, Debug, Eq, MallocSizeOf, PartialEq, ToComputedValue, ToCss)] +pub struct JustifyContent(pub ContentDistribution); + +impl Parse for JustifyContent { + fn parse<'i, 't>( + _: &ParserContext, + input: &mut Parser<'i, 't>, + ) -> Result> { + Ok(JustifyContent(ContentDistribution::parse( + input, + AxisDirection::Inline, + )?)) + } +} + +#[cfg(feature = "gecko")] +impl From for JustifyContent { + fn from(bits: u16) -> Self { + JustifyContent(ContentDistribution::from_bits(bits)) + } +} + +#[cfg(feature = "gecko")] +impl From for u16 { + fn from(v: JustifyContent) -> u16 { + v.0.as_bits() + } +} + /// -#[cfg_attr(feature = "gecko", derive(MallocSizeOf))] -#[derive(Clone, Copy, Debug, Eq, PartialEq, ToComputedValue, ToCss)] +#[derive(Clone, Copy, Debug, Eq, MallocSizeOf, PartialEq, ToComputedValue, ToCss)] pub struct SelfAlignment(pub AlignFlags); impl SelfAlignment { @@ -249,32 +299,105 @@ impl SelfAlignment { SelfAlignment(AlignFlags::AUTO) } + /// Returns whether this value is valid for both axis directions. + pub fn is_valid_on_both_axes(&self) -> bool { + match self.0.value() { + // is only allowed on the block axis. + AlignFlags::BASELINE | + AlignFlags::LAST_BASELINE => false, + + // left | right are only allowed on the inline axis. + AlignFlags::LEFT | + AlignFlags::RIGHT => false, + + _ => true, + } + } + /// Whether this value has extra flags. #[inline] pub fn has_extra_flags(self) -> bool { self.0.intersects(AlignFlags::FLAG_BITS) } -} + /// Parse a self-alignment value on one of the axis. + pub fn parse<'i, 't>( + input: &mut Parser<'i, 't>, + axis: AxisDirection, + ) -> Result> { + // , only on the block axis. + if axis == AxisDirection::Block { + if let Ok(value) = input.try(parse_baseline) { + return Ok(SelfAlignment(value)); + } + } -impl Parse for SelfAlignment { - // auto | normal | stretch | | - // [ ? && ] - fn parse<'i, 't>(_: &ParserContext, input: &mut Parser<'i, 't>) -> Result> { - // auto | normal | stretch | - if let Ok(value) = input.try(parse_auto_normal_stretch_baseline) { + // auto | normal | stretch + if let Ok(value) = input.try(parse_auto_normal_stretch) { return Ok(SelfAlignment(value)) } - // [ ? && ] - Ok(SelfAlignment(parse_overflow_self_position(input)?)) + + // ? + let overflow_position = + input.try(parse_overflow_position) + .unwrap_or(AlignFlags::empty()); + let self_position = parse_self_position(input, axis)?; + Ok(SelfAlignment(overflow_position | self_position)) + } +} + +/// The specified value of the align-self property. +/// +/// +#[derive(Clone, Copy, Debug, Eq, MallocSizeOf, PartialEq, ToComputedValue, ToCss)] +pub struct AlignSelf(pub SelfAlignment); + +impl Parse for AlignSelf { + fn parse<'i, 't>(_: &ParserContext, input: &mut Parser<'i, 't>) -> Result> { + Ok(AlignSelf(SelfAlignment::parse(input, AxisDirection::Block)?)) + } +} + +impl From for AlignSelf { + fn from(bits: u8) -> Self { + AlignSelf(SelfAlignment(AlignFlags::from_bits_truncate(bits))) + } +} + +impl From for u8 { + fn from(align: AlignSelf) -> u8 { + (align.0).0.bits() + } +} + +/// The specified value of the justify-self property. +/// +/// +#[derive(Clone, Copy, Debug, Eq, MallocSizeOf, PartialEq, ToComputedValue, ToCss)] +pub struct JustifySelf(pub SelfAlignment); + +impl Parse for JustifySelf { + fn parse<'i, 't>(_: &ParserContext, input: &mut Parser<'i, 't>) -> Result> { + Ok(JustifySelf(SelfAlignment::parse(input, AxisDirection::Inline)?)) + } +} + +impl From for JustifySelf { + fn from(bits: u8) -> Self { + JustifySelf(SelfAlignment(AlignFlags::from_bits_truncate(bits))) + } +} + +impl From for u8 { + fn from(justify: JustifySelf) -> u8 { + (justify.0).0.bits() } } /// Value of the `align-items` property /// /// -#[cfg_attr(feature = "gecko", derive(MallocSizeOf))] -#[derive(Clone, Copy, Debug, Eq, PartialEq, ToComputedValue, ToCss)] +#[derive(Clone, Copy, Debug, Eq, MallocSizeOf, PartialEq, ToComputedValue, ToCss)] pub struct AlignItems(pub AlignFlags); impl AlignItems { @@ -294,22 +417,28 @@ impl AlignItems { impl Parse for AlignItems { // normal | stretch | | - // [ ? && ] + // ? fn parse<'i, 't>(_: &ParserContext, input: &mut Parser<'i, 't>) -> Result> { - // normal | stretch | - if let Ok(value) = input.try(parse_normal_stretch_baseline) { + // + if let Ok(baseline) = input.try(parse_baseline) { + return Ok(AlignItems(baseline)); + } + + // normal | stretch + if let Ok(value) = input.try(parse_normal_stretch) { return Ok(AlignItems(value)) } - // [ ? && ] - Ok(AlignItems(parse_overflow_self_position(input)?)) + // ? + let overflow = input.try(parse_overflow_position).unwrap_or(AlignFlags::empty()); + let self_position = parse_self_position(input, AxisDirection::Block)?; + Ok(AlignItems(self_position | overflow)) } } /// Value of the `justify-items` property /// /// -#[cfg_attr(feature = "gecko", derive(MallocSizeOf))] -#[derive(Clone, Copy, Debug, Eq, PartialEq, ToCss)] +#[derive(Clone, Copy, Debug, Eq, MallocSizeOf, PartialEq, ToCss)] pub struct JustifyItems(pub AlignFlags); impl JustifyItems { @@ -332,52 +461,49 @@ impl JustifyItems { } } - impl Parse for JustifyItems { - // auto | normal | stretch | | - // [ ? && ] - // [ legacy && [ left | right | center ] ] fn parse<'i, 't>(_: &ParserContext, input: &mut Parser<'i, 't>) -> Result> { - // auto | normal | stretch | - if let Ok(value) = input.try(parse_auto_normal_stretch_baseline) { + // + // + // It's weird that this accepts , but not the + // justify-self / justify-content properties... + if let Ok(baseline) = input.try(parse_baseline) { + return Ok(JustifyItems(baseline)); + } + + // auto | normal | stretch + // + // FIXME(emilio): auto is no longer a keyword in the current spec, and + // has been renamed to legacy, but that needs different changes because + // right now it's the initial value for both style systems, and has that + // weird behavior of "inheriting" into descendants. + // + // Fix this in both. + // + // See also: + // https://bugs.webkit.org/show_bug.cgi?id=172711 + // https://bugs.chromium.org/p/chromium/issues/detail?id=726148 + // + if let Ok(value) = input.try(parse_auto_normal_stretch) { return Ok(JustifyItems(value)) } - // [ legacy && [ left | right | center ] ] + + // [ legacy || [ left | right | center ] ] if let Ok(value) = input.try(parse_legacy) { return Ok(JustifyItems(value)) } - // [ ? && ] - Ok(JustifyItems(parse_overflow_self_position(input)?)) + + // ? + let overflow = input.try(parse_overflow_position).unwrap_or(AlignFlags::empty()); + let self_position = parse_self_position(input, AxisDirection::Inline)?; + Ok(JustifyItems(overflow | self_position)) } } -#[cfg(feature = "gecko")] -impl From for ContentDistribution { - fn from(bits: u16) -> ContentDistribution { - let primary = - AlignFlags::from_bits_truncate((bits & ALIGN_ALL_BITS) as u8); - let fallback = - AlignFlags::from_bits_truncate((bits >> ALIGN_ALL_SHIFT) as u8); - ContentDistribution::with_fallback(primary, fallback) - } -} - -#[cfg(feature = "gecko")] -impl From for u16 { - fn from(v: ContentDistribution) -> u16 { - v.primary().bits() as u16 | - ((v.fallback().bits() as u16) << ALIGN_ALL_SHIFT) - } -} - -// auto | normal | stretch | -fn parse_auto_normal_stretch_baseline<'i, 't>( +// auto | normal | stretch +fn parse_auto_normal_stretch<'i, 't>( input: &mut Parser<'i, 't>, ) -> Result> { - if let Ok(baseline) = input.try(parse_baseline) { - return Ok(baseline); - } - try_match_ident_ignore_ascii_case! { input, "auto" => Ok(AlignFlags::AUTO), "normal" => Ok(AlignFlags::NORMAL), @@ -386,30 +512,15 @@ fn parse_auto_normal_stretch_baseline<'i, 't>( } // normal | stretch | -fn parse_normal_stretch_baseline<'i, 't>(input: &mut Parser<'i, 't>) -> Result> { - if let Ok(baseline) = input.try(parse_baseline) { - return Ok(baseline); - } - +fn parse_normal_stretch<'i, 't>(input: &mut Parser<'i, 't>) -> Result> { try_match_ident_ignore_ascii_case! { input, "normal" => Ok(AlignFlags::NORMAL), "stretch" => Ok(AlignFlags::STRETCH), } } -// normal | -fn parse_normal_or_baseline<'i, 't>(input: &mut Parser<'i, 't>) -> Result> { - if let Ok(baseline) = input.try(parse_baseline) { - return Ok(baseline); - } - - input.expect_ident_matching("normal")?; - Ok(AlignFlags::NORMAL) -} - // fn parse_baseline<'i, 't>(input: &mut Parser<'i, 't>) -> Result> { - // FIXME: remove clone() when lifetimes are non-lexical try_match_ident_ignore_ascii_case! { input, "baseline" => Ok(AlignFlags::BASELINE), "first" => { @@ -433,37 +544,6 @@ fn parse_content_distribution<'i, 't>(input: &mut Parser<'i, 't>) -> Result? && ] -fn parse_overflow_content_position<'i, 't>(input: &mut Parser<'i, 't>) -> Result> { - // followed by optional - if let Ok(mut content) = input.try(parse_content_position) { - if let Ok(overflow) = input.try(parse_overflow_position) { - content |= overflow; - } - return Ok(content) - } - // followed by required - if let Ok(overflow) = parse_overflow_position(input) { - if let Ok(content) = parse_content_position(input) { - return Ok(overflow | content) - } - } - return Err(input.new_custom_error(StyleParseErrorKind::UnspecifiedError)) -} - -// -fn parse_content_position<'i, 't>(input: &mut Parser<'i, 't>) -> Result> { - try_match_ident_ignore_ascii_case! { input, - "start" => Ok(AlignFlags::START), - "end" => Ok(AlignFlags::END), - "flex-start" => Ok(AlignFlags::FLEX_START), - "flex-end" => Ok(AlignFlags::FLEX_END), - "center" => Ok(AlignFlags::CENTER), - "left" => Ok(AlignFlags::LEFT), - "right" => Ok(AlignFlags::RIGHT), - } -} - // fn parse_overflow_position<'i, 't>(input: &mut Parser<'i, 't>) -> Result> { try_match_ident_ignore_ascii_case! { input, @@ -472,37 +552,22 @@ fn parse_overflow_position<'i, 't>(input: &mut Parser<'i, 't>) -> Result? && ] -fn parse_overflow_self_position<'i, 't>(input: &mut Parser<'i, 't>) -> Result> { - // followed by optional - if let Ok(mut self_position) = input.try(parse_self_position) { - if let Ok(overflow) = input.try(parse_overflow_position) { - self_position |= overflow; - } - return Ok(self_position) - } - // followed by required - if let Ok(overflow) = parse_overflow_position(input) { - if let Ok(self_position) = parse_self_position(input) { - return Ok(overflow | self_position) - } - } - return Err(input.new_custom_error(StyleParseErrorKind::UnspecifiedError)) -} - -// -fn parse_self_position<'i, 't>(input: &mut Parser<'i, 't>) -> Result> { - try_match_ident_ignore_ascii_case! { input, - "start" => Ok(AlignFlags::START), - "end" => Ok(AlignFlags::END), - "flex-start" => Ok(AlignFlags::FLEX_START), - "flex-end" => Ok(AlignFlags::FLEX_END), - "center" => Ok(AlignFlags::CENTER), - "left" => Ok(AlignFlags::LEFT), - "right" => Ok(AlignFlags::RIGHT), - "self-start" => Ok(AlignFlags::SELF_START), - "self-end" => Ok(AlignFlags::SELF_END), - } +// | left | right in the inline axis. +fn parse_self_position<'i, 't>( + input: &mut Parser<'i, 't>, + axis: AxisDirection, +) -> Result> { + Ok(try_match_ident_ignore_ascii_case! { input, + "start" => AlignFlags::START, + "end" => AlignFlags::END, + "flex-start" => AlignFlags::FLEX_START, + "flex-end" => AlignFlags::FLEX_END, + "center" => AlignFlags::CENTER, + "self-start" => AlignFlags::SELF_START, + "self-end" => AlignFlags::SELF_END, + "left" if axis == AxisDirection::Inline => AlignFlags::LEFT, + "right" if axis == AxisDirection::Inline => AlignFlags::RIGHT, + }) } // [ legacy && [ left | right | center ] ] diff --git a/components/style/values/specified/mod.rs b/components/style/values/specified/mod.rs index 2a9e05f7e75..877580f799d 100644 --- a/components/style/values/specified/mod.rs +++ b/components/style/values/specified/mod.rs @@ -26,7 +26,9 @@ use values::specified::calc::CalcNode; pub use properties::animated_properties::TransitionProperty; pub use self::angle::Angle; #[cfg(feature = "gecko")] -pub use self::align::{AlignItems, ContentDistribution, SelfAlignment, JustifyItems}; +pub use self::align::{AlignContent, JustifyContent, AlignItems, ContentDistribution, SelfAlignment, JustifyItems}; +#[cfg(feature = "gecko")] +pub use self::align::{AlignSelf, JustifySelf}; pub use self::background::{BackgroundRepeat, BackgroundSize}; pub use self::border::{BorderCornerRadius, BorderImageSlice, BorderImageWidth}; pub use self::border::{BorderImageSideWidth, BorderRadius, BorderSideWidth, BorderSpacing};