diff options
Diffstat (limited to 'servo/components/style')
128 files changed, 3002 insertions, 1576 deletions
diff --git a/servo/components/style/Cargo.toml b/servo/components/style/Cargo.toml index acf1bcf6fe..d6e37d4903 100644 --- a/servo/components/style/Cargo.toml +++ b/servo/components/style/Cargo.toml @@ -21,8 +21,6 @@ gecko = ["nsstring", "serde", "style_traits/gecko", "bindgen", "regex", "toml", servo = ["serde", "style_traits/servo", "servo_atoms", "servo_config", "html5ever", "cssparser/serde", "encoding_rs", "malloc_size_of/servo", "arrayvec/use_union", "servo_url", "string_cache", "to_shmem/servo", "servo_arc/servo"] -servo-layout-2013 = [] -servo-layout-2020 = [] gecko_debug = [] gecko_refcount_logging = [] diff --git a/servo/components/style/animation.rs b/servo/components/style/animation.rs index b865120aba..1cab5da84e 100644 --- a/servo/components/style/animation.rs +++ b/servo/components/style/animation.rs @@ -1273,9 +1273,10 @@ pub fn start_transitions_if_applicable( ) -> PropertyDeclarationIdSet { let mut properties_that_transition = PropertyDeclarationIdSet::default(); for transition in new_style.transition_properties() { - let physical_property = PropertyDeclarationId::Longhand( - transition.longhand_id.to_physical(new_style.writing_mode), - ); + let physical_property = transition + .property + .as_borrowed() + .to_physical(new_style.writing_mode); if properties_that_transition.contains(physical_property) { continue; } diff --git a/servo/components/style/applicable_declarations.rs b/servo/components/style/applicable_declarations.rs index 96049b76e3..b2fb05b0b8 100644 --- a/servo/components/style/applicable_declarations.rs +++ b/servo/components/style/applicable_declarations.rs @@ -142,8 +142,9 @@ pub struct ApplicableDeclarationBlock { /// The style source, either a style rule, or a property declaration block. #[ignore_malloc_size_of = "Arc"] pub source: StyleSource, - /// The bits containing the source order, cascade level, and shadow cascade - /// order. + /// Order of appearance in which this rule appears - Set to 0 if not relevant + /// (e.g. Declaration from `style="/*...*/"`, presentation hints, animations + /// - See `CascadePriority` instead). source_order: u32, /// The specificity of the selector. pub specificity: u32, diff --git a/servo/components/style/bloom.rs b/servo/components/style/bloom.rs index 824acb7114..63be881505 100644 --- a/servo/components/style/bloom.rs +++ b/servo/components/style/bloom.rs @@ -8,6 +8,7 @@ #![deny(missing_docs)] use crate::dom::{SendElement, TElement}; +use crate::LocalName; use atomic_refcell::{AtomicRefCell, AtomicRefMut}; use owning_ref::OwningHandle; use selectors::bloom::BloomFilter; @@ -107,8 +108,8 @@ impl<E: TElement> PushedElement<E> { /// We do this for attributes that are very common but not commonly used in /// selectors. #[inline] -pub fn is_attr_name_excluded_from_filter(atom: &crate::Atom) -> bool { - *atom == atom!("class") || *atom == atom!("id") || *atom == atom!("style") +pub fn is_attr_name_excluded_from_filter(name: &LocalName) -> bool { + *name == local_name!("class") || *name == local_name!("id") || *name == local_name!("style") } /// Gather all relevant hash for fast-reject filters from an element. diff --git a/servo/components/style/build.rs b/servo/components/style/build.rs index 2247e87618..4b27edbe2c 100644 --- a/servo/components/style/build.rs +++ b/servo/components/style/build.rs @@ -71,16 +71,12 @@ fn generate_properties(engine: &str) { fn main() { let gecko = cfg!(feature = "gecko"); let servo = cfg!(feature = "servo"); - let l2013 = cfg!(feature = "servo-layout-2013"); - let l2020 = cfg!(feature = "servo-layout-2020"); - let engine = match (gecko, servo, l2013, l2020) { - (true, false, false, false) => "gecko", - (false, true, true, false) => "servo-2013", - (false, true, false, true) => "servo-2020", + let engine = match (gecko, servo) { + (true, false) => "gecko", + (false, true) => "servo", _ => panic!( "\n\n\ - The style crate requires enabling one of its 'servo' or 'gecko' feature flags \ - and, in the 'servo' case, one of 'servo-layout-2013' or 'servo-layout-2020'.\ + The style crate requires enabling one of its 'servo' or 'gecko' feature flags. \ \n\n" ), }; diff --git a/servo/components/style/color/color_function.rs b/servo/components/style/color/color_function.rs new file mode 100644 index 0000000000..2edb4fff3b --- /dev/null +++ b/servo/components/style/color/color_function.rs @@ -0,0 +1,198 @@ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at https://mozilla.org/MPL/2.0/. */ + +//! Output of parsing a color function, e.g. rgb(..), hsl(..), color(..) + +use crate::values::normalize; +use cssparser::color::{PredefinedColorSpace, OPAQUE}; + +use super::{ + component::ColorComponent, + convert::normalize_hue, + parsing::{NumberOrAngle, NumberOrPercentage}, + AbsoluteColor, ColorSpace, +}; + +/// Represents a specified color function. +#[derive(Debug)] +pub enum ColorFunction { + /// <https://drafts.csswg.org/css-color-4/#rgb-functions> + Rgb( + ColorComponent<u8>, // red + ColorComponent<u8>, // green + ColorComponent<u8>, // blue + ColorComponent<NumberOrPercentage>, // alpha + ), + /// <https://drafts.csswg.org/css-color-4/#the-hsl-notation> + Hsl( + ColorComponent<NumberOrAngle>, // hue + ColorComponent<NumberOrPercentage>, // saturation + ColorComponent<NumberOrPercentage>, // lightness + ColorComponent<NumberOrPercentage>, // alpha + ), + /// <https://drafts.csswg.org/css-color-4/#the-hwb-notation> + Hwb( + ColorComponent<NumberOrAngle>, // hue + ColorComponent<NumberOrPercentage>, // whiteness + ColorComponent<NumberOrPercentage>, // blackness + ColorComponent<NumberOrPercentage>, // alpha + ), + /// <https://drafts.csswg.org/css-color-4/#specifying-lab-lch> + Lab( + ColorComponent<NumberOrPercentage>, // lightness + ColorComponent<NumberOrPercentage>, // a + ColorComponent<NumberOrPercentage>, // b + ColorComponent<NumberOrPercentage>, // alpha + ), + /// <https://drafts.csswg.org/css-color-4/#specifying-lab-lch> + Lch( + ColorComponent<NumberOrPercentage>, // lightness + ColorComponent<NumberOrPercentage>, // chroma + ColorComponent<NumberOrAngle>, // hue + ColorComponent<NumberOrPercentage>, // alpha + ), + /// <https://drafts.csswg.org/css-color-4/#specifying-oklab-oklch> + Oklab( + ColorComponent<NumberOrPercentage>, // lightness + ColorComponent<NumberOrPercentage>, // a + ColorComponent<NumberOrPercentage>, // b + ColorComponent<NumberOrPercentage>, // alpha + ), + /// <https://drafts.csswg.org/css-color-4/#specifying-oklab-oklch> + Oklch( + ColorComponent<NumberOrPercentage>, // lightness + ColorComponent<NumberOrPercentage>, // chroma + ColorComponent<NumberOrAngle>, // hue + ColorComponent<NumberOrPercentage>, // alpha + ), + /// <https://drafts.csswg.org/css-color-4/#color-function> + Color( + PredefinedColorSpace, + ColorComponent<NumberOrPercentage>, // red / x + ColorComponent<NumberOrPercentage>, // green / y + ColorComponent<NumberOrPercentage>, // blue / z + ColorComponent<NumberOrPercentage>, // alpha + ), +} + +impl ColorFunction { + /// Try to resolve the color function to an [`AbsoluteColor`] that does not + /// contain any variables (currentcolor, color components, etc.). + pub fn resolve_to_absolute(&self) -> AbsoluteColor { + macro_rules! value { + ($v:expr) => {{ + match $v { + ColorComponent::None => None, + // value should be Copy. + ColorComponent::Value(value) => Some(*value), + } + }}; + } + + macro_rules! alpha { + ($alpha:expr) => {{ + value!($alpha).map(|value| normalize(value.to_number(1.0)).clamp(0.0, OPAQUE)) + }}; + } + + match self { + ColorFunction::Rgb(r, g, b, alpha) => { + let r = value!(r).unwrap_or(0); + let g = value!(g).unwrap_or(0); + let b = value!(b).unwrap_or(0); + + AbsoluteColor::srgb_legacy(r, g, b, alpha!(alpha).unwrap_or(0.0)) + }, + ColorFunction::Hsl(h, s, l, alpha) => { + // Percent reference range for S and L: 0% = 0.0, 100% = 100.0 + const LIGHTNESS_RANGE: f32 = 100.0; + const SATURATION_RANGE: f32 = 100.0; + + AbsoluteColor::new( + ColorSpace::Hsl, + value!(h).map(|angle| normalize_hue(angle.degrees())), + value!(s).map(|s| s.to_number(SATURATION_RANGE).clamp(0.0, SATURATION_RANGE)), + value!(l).map(|l| l.to_number(LIGHTNESS_RANGE).clamp(0.0, LIGHTNESS_RANGE)), + alpha!(alpha), + ) + }, + ColorFunction::Hwb(h, w, b, alpha) => { + // Percent reference range for W and B: 0% = 0.0, 100% = 100.0 + const WHITENESS_RANGE: f32 = 100.0; + const BLACKNESS_RANGE: f32 = 100.0; + + AbsoluteColor::new( + ColorSpace::Hwb, + value!(h).map(|angle| normalize_hue(angle.degrees())), + value!(w).map(|w| w.to_number(WHITENESS_RANGE).clamp(0.0, WHITENESS_RANGE)), + value!(b).map(|b| b.to_number(BLACKNESS_RANGE).clamp(0.0, BLACKNESS_RANGE)), + alpha!(alpha), + ) + }, + ColorFunction::Lab(l, a, b, alpha) => { + // for L: 0% = 0.0, 100% = 100.0 + // for a and b: -100% = -125, 100% = 125 + const LIGHTNESS_RANGE: f32 = 100.0; + const A_B_RANGE: f32 = 125.0; + + AbsoluteColor::new( + ColorSpace::Lab, + value!(l).map(|l| l.to_number(LIGHTNESS_RANGE)), + value!(a).map(|a| a.to_number(A_B_RANGE)), + value!(b).map(|b| b.to_number(A_B_RANGE)), + alpha!(alpha), + ) + }, + ColorFunction::Lch(l, c, h, alpha) => { + // for L: 0% = 0.0, 100% = 100.0 + // for C: 0% = 0, 100% = 150 + const LIGHTNESS_RANGE: f32 = 100.0; + const CHROMA_RANGE: f32 = 150.0; + + AbsoluteColor::new( + ColorSpace::Lch, + value!(l).map(|l| l.to_number(LIGHTNESS_RANGE)), + value!(c).map(|c| c.to_number(CHROMA_RANGE)), + value!(h).map(|angle| normalize_hue(angle.degrees())), + alpha!(alpha), + ) + }, + ColorFunction::Oklab(l, a, b, alpha) => { + // for L: 0% = 0.0, 100% = 1.0 + // for a and b: -100% = -0.4, 100% = 0.4 + const LIGHTNESS_RANGE: f32 = 1.0; + const A_B_RANGE: f32 = 0.4; + + AbsoluteColor::new( + ColorSpace::Oklab, + value!(l).map(|l| l.to_number(LIGHTNESS_RANGE)), + value!(a).map(|a| a.to_number(A_B_RANGE)), + value!(b).map(|b| b.to_number(A_B_RANGE)), + alpha!(alpha), + ) + }, + ColorFunction::Oklch(l, c, h, alpha) => { + // for L: 0% = 0.0, 100% = 1.0 + // for C: 0% = 0.0 100% = 0.4 + const LIGHTNESS_RANGE: f32 = 1.0; + const CHROMA_RANGE: f32 = 0.4; + + AbsoluteColor::new( + ColorSpace::Oklch, + value!(l).map(|l| l.to_number(LIGHTNESS_RANGE)), + value!(c).map(|c| c.to_number(CHROMA_RANGE)), + value!(h).map(|angle| normalize_hue(angle.degrees())), + alpha!(alpha), + ) + }, + ColorFunction::Color(color_space, r, g, b, alpha) => AbsoluteColor::new( + (*color_space).into(), + value!(r).map(|c| c.to_number(1.0)), + value!(g).map(|c| c.to_number(1.0)), + value!(b).map(|c| c.to_number(1.0)), + alpha!(alpha), + ), + } + } +} diff --git a/servo/components/style/color/component.rs b/servo/components/style/color/component.rs index 9f101a460c..5f9d8a137e 100644 --- a/servo/components/style/color/component.rs +++ b/servo/components/style/color/component.rs @@ -4,8 +4,18 @@ //! Parse/serialize and resolve a single color component. +use crate::{ + parser::ParserContext, + values::{ + generics::calc::CalcUnits, + specified::calc::{CalcNode as SpecifiedCalcNode, Leaf as SpecifiedLeaf}, + }, +}; +use cssparser::{Parser, Token}; +use style_traits::{ParseError, StyleParseErrorKind}; + /// A single color component. -#[derive(Clone, MallocSizeOf, PartialEq, ToShmem)] +#[derive(Clone, Debug, MallocSizeOf, PartialEq, ToShmem)] pub enum ColorComponent<ValueType> { /// The "none" keyword. None, @@ -46,3 +56,49 @@ impl<ValueType> ColorComponent<ValueType> { } } } + +/// An utility trait that allows the construction of [ColorComponent] +/// `ValueType`'s after parsing a color component. +pub trait ColorComponentType: Sized { + /// Return the [CalcUnits] flags that the impl can handle. + fn units() -> CalcUnits; + + /// Try to create a new component from the given token. + fn try_from_token(token: &Token) -> Result<Self, ()>; + + /// Try to create a new component from the given [CalcNodeLeaf] that was + /// resolved from a [CalcNode]. + fn try_from_leaf(leaf: &SpecifiedLeaf) -> Result<Self, ()>; +} + +impl<ValueType: ColorComponentType> ColorComponent<ValueType> { + /// Parse a single [ColorComponent]. + pub fn parse<'i, 't>( + context: &ParserContext, + input: &mut Parser<'i, 't>, + allow_none: bool, + ) -> Result<Self, ParseError<'i>> { + let location = input.current_source_location(); + + match *input.next()? { + Token::Ident(ref value) if allow_none && value.eq_ignore_ascii_case("none") => { + Ok(ColorComponent::None) + }, + Token::Function(ref name) => { + let function = SpecifiedCalcNode::math_function(context, name, location)?; + let node = SpecifiedCalcNode::parse(context, input, function, ValueType::units())?; + + let Ok(resolved_leaf) = node.resolve() else { + return Err(location.new_custom_error(StyleParseErrorKind::UnspecifiedError)); + }; + + ValueType::try_from_leaf(&resolved_leaf) + .map(Self::Value) + .map_err(|_| location.new_custom_error(StyleParseErrorKind::UnspecifiedError)) + }, + ref t => ValueType::try_from_token(t) + .map(Self::Value) + .map_err(|_| location.new_unexpected_token_error(t.clone())), + } + } +} diff --git a/servo/components/style/color/mix.rs b/servo/components/style/color/mix.rs index bcc4628575..3b3970e1e0 100644 --- a/servo/components/style/color/mix.rs +++ b/servo/components/style/color/mix.rs @@ -402,7 +402,8 @@ fn adjust_hue(left: &mut f32, right: &mut f32, hue_interpolation: HueInterpolati // https://drafts.csswg.org/css-color/#longer HueInterpolationMethod::Longer => { let delta = *right - *left; - if 0. < delta && delta < 180. { + // In the specific case of delta == 0 we need to use Decreasing + if 0. <= delta && delta < 180. { *left += 360.; } else if -180. < delta && delta <= 0. { *right += 360.; diff --git a/servo/components/style/color/mod.rs b/servo/components/style/color/mod.rs index 6f35daaa8a..f7e661cddf 100644 --- a/servo/components/style/color/mod.rs +++ b/servo/components/style/color/mod.rs @@ -4,9 +4,13 @@ //! Color support functions. -pub mod component; +/// cbindgen:ignore +mod color_function; + /// cbindgen:ignore pub mod convert; + +pub mod component; pub mod mix; pub mod parsing; mod to_css; diff --git a/servo/components/style/color/parsing.rs b/servo/components/style/color/parsing.rs index 1ae32c4ad7..68bcee6c56 100644 --- a/servo/components/style/color/parsing.rs +++ b/servo/components/style/color/parsing.rs @@ -8,14 +8,34 @@ //! Relative colors, color-mix, system colors, and other such things require better calc() support //! and integration. -use crate::color::component::ColorComponent; -use cssparser::color::{ - clamp_floor_256_f32, clamp_unit_f32, parse_hash_color, PredefinedColorSpace, OPAQUE, +use super::{ + color_function::ColorFunction, + component::{ColorComponent, ColorComponentType}, + AbsoluteColor, +}; +use crate::{ + parser::ParserContext, + values::{ + generics::calc::CalcUnits, + specified::{ + angle::Angle as SpecifiedAngle, calc::Leaf as SpecifiedLeaf, + color::Color as SpecifiedColor, + }, + }, +}; +use cssparser::{ + color::{clamp_floor_256_f32, clamp_unit_f32, parse_hash_color, PredefinedColorSpace, OPAQUE}, + match_ignore_ascii_case, CowRcStr, Parser, Token, }; -use cssparser::{match_ignore_ascii_case, CowRcStr, Parser, Token}; use std::str::FromStr; use style_traits::{ParseError, StyleParseErrorKind}; +/// Returns true if the relative color syntax pref is enabled. +#[inline] +pub fn rcs_enabled() -> bool { + static_prefs::pref!("layout.css.relative-color-syntax.enabled") +} + impl From<u8> for ColorComponent<u8> { #[inline] fn from(value: u8) -> Self { @@ -29,56 +49,39 @@ impl From<u8> for ColorComponent<u8> { /// CSS escaping (if relevant) should be resolved before calling this function. /// (For example, the value of an `Ident` token is fine.) #[inline] -pub fn parse_color_keyword<Output>(ident: &str) -> Result<Output, ()> -where - Output: FromParsedColor, -{ +pub fn parse_color_keyword(ident: &str) -> Result<SpecifiedColor, ()> { Ok(match_ignore_ascii_case! { ident, - "transparent" => Output::from_rgba( - 0u8.into(), - 0u8.into(), - 0u8.into(), - ColorComponent::Value(NumberOrPercentage::Number { value: 0.0 }), - ), - "currentcolor" => Output::from_current_color(), + "transparent" => { + SpecifiedColor::from_absolute_color(AbsoluteColor::srgb_legacy(0u8, 0u8, 0u8, 0.0)) + }, + "currentcolor" => SpecifiedColor::CurrentColor, _ => { let (r, g, b) = cssparser::color::parse_named_color(ident)?; - Output::from_rgba( - r.into(), - g.into(), - b.into(), - ColorComponent::Value(NumberOrPercentage::Number { value: OPAQUE }), - ) + SpecifiedColor::from_absolute_color(AbsoluteColor::srgb_legacy(r, g, b, OPAQUE)) }, }) } /// Parse a CSS color using the specified [`ColorParser`] and return a new color /// value on success. -pub fn parse_color_with<'i, 't, P>( - color_parser: &P, +pub fn parse_color_with<'i, 't>( + color_parser: &ColorParser<'_, '_>, input: &mut Parser<'i, 't>, -) -> Result<P::Output, ParseError<'i>> -where - P: ColorParser<'i>, -{ +) -> Result<SpecifiedColor, ParseError<'i>> { let location = input.current_source_location(); let token = input.next()?; match *token { Token::Hash(ref value) | Token::IDHash(ref value) => parse_hash_color(value.as_bytes()) .map(|(r, g, b, a)| { - P::Output::from_rgba( - r.into(), - g.into(), - b.into(), - ColorComponent::Value(NumberOrPercentage::Number { value: a }), - ) + SpecifiedColor::from_absolute_color(AbsoluteColor::srgb_legacy(r, g, b, a)) }), Token::Ident(ref value) => parse_color_keyword(value), Token::Function(ref name) => { let name = name.clone(); return input.parse_nested_block(|arguments| { - parse_color_function(color_parser, name, arguments) + Ok(SpecifiedColor::from_absolute_color( + parse_color_function(color_parser, name, arguments)?.resolve_to_absolute(), + )) }); }, _ => Err(()), @@ -88,22 +91,19 @@ where /// Parse one of the color functions: rgba(), lab(), color(), etc. #[inline] -fn parse_color_function<'i, 't, P>( - color_parser: &P, +fn parse_color_function<'i, 't>( + color_parser: &ColorParser<'_, '_>, name: CowRcStr<'i>, arguments: &mut Parser<'i, 't>, -) -> Result<P::Output, ParseError<'i>> -where - P: ColorParser<'i>, -{ +) -> Result<ColorFunction, ParseError<'i>> { let color = match_ignore_ascii_case! { &name, "rgb" | "rgba" => parse_rgb(color_parser, arguments), "hsl" | "hsla" => parse_hsl(color_parser, arguments), "hwb" => parse_hwb(color_parser, arguments), - "lab" => parse_lab_like(color_parser, arguments, P::Output::from_lab), - "lch" => parse_lch_like(color_parser, arguments, P::Output::from_lch), - "oklab" => parse_lab_like(color_parser, arguments, P::Output::from_oklab), - "oklch" => parse_lch_like(color_parser, arguments, P::Output::from_oklch), + "lab" => parse_lab_like(color_parser, arguments, ColorFunction::Lab), + "lch" => parse_lch_like(color_parser, arguments, ColorFunction::Lch), + "oklab" => parse_lab_like(color_parser, arguments, ColorFunction::Oklab), + "oklch" => parse_lch_like(color_parser, arguments, ColorFunction::Oklch), "color" => parse_color_with_color_space(color_parser, arguments), _ => return Err(arguments.new_unexpected_token_error(Token::Ident(name))), }?; @@ -113,13 +113,10 @@ where Ok(color) } -fn parse_legacy_alpha<'i, 't, P>( - color_parser: &P, +fn parse_legacy_alpha<'i, 't>( + color_parser: &ColorParser<'_, '_>, arguments: &mut Parser<'i, 't>, -) -> Result<ColorComponent<NumberOrPercentage>, ParseError<'i>> -where - P: ColorParser<'i>, -{ +) -> Result<ColorComponent<NumberOrPercentage>, ParseError<'i>> { if !arguments.is_exhausted() { arguments.expect_comma()?; color_parser.parse_number_or_percentage(arguments, false) @@ -130,13 +127,10 @@ where } } -fn parse_modern_alpha<'i, 't, P>( - color_parser: &P, +fn parse_modern_alpha<'i, 't>( + color_parser: &ColorParser<'_, '_>, arguments: &mut Parser<'i, 't>, -) -> Result<ColorComponent<NumberOrPercentage>, ParseError<'i>> -where - P: ColorParser<'i>, -{ +) -> Result<ColorComponent<NumberOrPercentage>, ParseError<'i>> { if !arguments.is_exhausted() { arguments.expect_delim('/')?; color_parser.parse_number_or_percentage(arguments, true) @@ -157,22 +151,45 @@ impl ColorComponent<NumberOrPercentage> { } } +/// Parse the relative color syntax "from" syntax `from <color>`. +fn parse_origin_color<'i, 't>( + color_parser: &ColorParser<'_, '_>, + arguments: &mut Parser<'i, 't>, +) -> Result<Option<SpecifiedColor>, ParseError<'i>> { + if !rcs_enabled() { + return Ok(None); + } + + // Not finding the from keyword is not an error, it just means we don't + // have an origin color. + if arguments + .try_parse(|p| p.expect_ident_matching("from")) + .is_err() + { + return Ok(None); + } + + // We still fail if we can't parse the origin color. + parse_color_with(color_parser, arguments).map(|color| Some(color)) +} + #[inline] -fn parse_rgb<'i, 't, P>( - color_parser: &P, +fn parse_rgb<'i, 't>( + color_parser: &ColorParser<'_, '_>, arguments: &mut Parser<'i, 't>, -) -> Result<P::Output, ParseError<'i>> -where - P: ColorParser<'i>, -{ +) -> Result<ColorFunction, ParseError<'i>> { + let origin_color = parse_origin_color(color_parser, arguments)?; + let location = arguments.current_source_location(); let maybe_red = color_parser.parse_number_or_percentage(arguments, true)?; // If the first component is not "none" and is followed by a comma, then we - // are parsing the legacy syntax. - let is_legacy_syntax = - !maybe_red.is_none() && arguments.try_parse(|p| p.expect_comma()).is_ok(); + // are parsing the legacy syntax. Legacy syntax also doesn't support an + // origin color. + let is_legacy_syntax = origin_color.is_none() && + !maybe_red.is_none() && + arguments.try_parse(|p| p.expect_comma()).is_ok(); let (red, green, blue, alpha) = if is_legacy_syntax { let Ok(is_percentage) = maybe_red.is_percentage() else { @@ -217,25 +234,26 @@ where (red, green, blue, alpha) }; - Ok(P::Output::from_rgba(red, green, blue, alpha)) + Ok(ColorFunction::Rgb(red, green, blue, alpha)) } /// Parses hsl syntax. /// /// <https://drafts.csswg.org/css-color/#the-hsl-notation> #[inline] -fn parse_hsl<'i, 't, P>( - color_parser: &P, +fn parse_hsl<'i, 't>( + color_parser: &ColorParser<'_, '_>, arguments: &mut Parser<'i, 't>, -) -> Result<P::Output, ParseError<'i>> -where - P: ColorParser<'i>, -{ +) -> Result<ColorFunction, ParseError<'i>> { + let origin_color = parse_origin_color(color_parser, arguments)?; + let hue = color_parser.parse_number_or_angle(arguments, true)?; // If the hue is not "none" and is followed by a comma, then we are parsing - // the legacy syntax. - let is_legacy_syntax = !hue.is_none() && arguments.try_parse(|p| p.expect_comma()).is_ok(); + // the legacy syntax. Legacy syntax also doesn't support an origin color. + let is_legacy_syntax = origin_color.is_none() && + !hue.is_none() && + arguments.try_parse(|p| p.expect_comma()).is_ok(); let (saturation, lightness, alpha) = if is_legacy_syntax { let saturation = color_parser @@ -260,29 +278,28 @@ where ) }; - Ok(P::Output::from_hsl(hue, saturation, lightness, alpha)) + Ok(ColorFunction::Hsl(hue, saturation, lightness, alpha)) } /// Parses hwb syntax. /// /// <https://drafts.csswg.org/css-color/#the-hbw-notation> #[inline] -fn parse_hwb<'i, 't, P>( - color_parser: &P, +fn parse_hwb<'i, 't>( + color_parser: &ColorParser<'_, '_>, arguments: &mut Parser<'i, 't>, -) -> Result<P::Output, ParseError<'i>> -where - P: ColorParser<'i>, -{ +) -> Result<ColorFunction, ParseError<'i>> { + let _origin_color = parse_origin_color(color_parser, arguments)?; + let (hue, whiteness, blackness, alpha) = parse_components( color_parser, arguments, - P::parse_number_or_angle, - P::parse_number_or_percentage, - P::parse_number_or_percentage, + ColorParser::parse_number_or_angle, + ColorParser::parse_number_or_percentage, + ColorParser::parse_number_or_percentage, )?; - Ok(P::Output::from_hwb(hue, whiteness, blackness, alpha)) + Ok(ColorFunction::Hwb(hue, whiteness, blackness, alpha)) } type IntoLabFn<Output> = fn( @@ -293,20 +310,19 @@ type IntoLabFn<Output> = fn( ) -> Output; #[inline] -fn parse_lab_like<'i, 't, P>( - color_parser: &P, +fn parse_lab_like<'i, 't>( + color_parser: &ColorParser<'_, '_>, arguments: &mut Parser<'i, 't>, - into_color: IntoLabFn<P::Output>, -) -> Result<P::Output, ParseError<'i>> -where - P: ColorParser<'i>, -{ + into_color: IntoLabFn<ColorFunction>, +) -> Result<ColorFunction, ParseError<'i>> { + let _origin_color = parse_origin_color(color_parser, arguments)?; + let (lightness, a, b, alpha) = parse_components( color_parser, arguments, - P::parse_number_or_percentage, - P::parse_number_or_percentage, - P::parse_number_or_percentage, + ColorParser::parse_number_or_percentage, + ColorParser::parse_number_or_percentage, + ColorParser::parse_number_or_percentage, )?; Ok(into_color(lightness, a, b, alpha)) @@ -320,20 +336,19 @@ type IntoLchFn<Output> = fn( ) -> Output; #[inline] -fn parse_lch_like<'i, 't, P>( - color_parser: &P, +fn parse_lch_like<'i, 't>( + color_parser: &ColorParser<'_, '_>, arguments: &mut Parser<'i, 't>, - into_color: IntoLchFn<P::Output>, -) -> Result<P::Output, ParseError<'i>> -where - P: ColorParser<'i>, -{ + into_color: IntoLchFn<ColorFunction>, +) -> Result<ColorFunction, ParseError<'i>> { + let _origin_color = parse_origin_color(color_parser, arguments)?; + let (lightness, chroma, hue, alpha) = parse_components( color_parser, arguments, - P::parse_number_or_percentage, - P::parse_number_or_percentage, - P::parse_number_or_angle, + ColorParser::parse_number_or_percentage, + ColorParser::parse_number_or_percentage, + ColorParser::parse_number_or_angle, )?; Ok(into_color(lightness, chroma, hue, alpha)) @@ -341,13 +356,12 @@ where /// Parse the color() function. #[inline] -fn parse_color_with_color_space<'i, 't, P>( - color_parser: &P, +fn parse_color_with_color_space<'i, 't>( + color_parser: &ColorParser<'_, '_>, arguments: &mut Parser<'i, 't>, -) -> Result<P::Output, ParseError<'i>> -where - P: ColorParser<'i>, -{ +) -> Result<ColorFunction, ParseError<'i>> { + let _origin_color = parse_origin_color(color_parser, arguments)?; + let color_space = { let location = arguments.current_source_location(); @@ -359,18 +373,12 @@ where let (c1, c2, c3, alpha) = parse_components( color_parser, arguments, - P::parse_number_or_percentage, - P::parse_number_or_percentage, - P::parse_number_or_percentage, + ColorParser::parse_number_or_percentage, + ColorParser::parse_number_or_percentage, + ColorParser::parse_number_or_percentage, )?; - Ok(P::Output::from_color_function( - color_space, - c1, - c2, - c3, - alpha, - )) + Ok(ColorFunction::Color(color_space, c1, c2, c3, alpha)) } type ComponentParseResult<'i, R1, R2, R3> = Result< @@ -384,18 +392,29 @@ type ComponentParseResult<'i, R1, R2, R3> = Result< >; /// Parse the color components and alpha with the modern [color-4] syntax. -pub fn parse_components<'i, 't, P, F1, F2, F3, R1, R2, R3>( - color_parser: &P, +pub fn parse_components<'a, 'b: 'a, 'i, 't, F1, F2, F3, R1, R2, R3>( + color_parser: &ColorParser<'a, 'b>, input: &mut Parser<'i, 't>, f1: F1, f2: F2, f3: F3, ) -> ComponentParseResult<'i, R1, R2, R3> where - P: ColorParser<'i>, - F1: FnOnce(&P, &mut Parser<'i, 't>, bool) -> Result<ColorComponent<R1>, ParseError<'i>>, - F2: FnOnce(&P, &mut Parser<'i, 't>, bool) -> Result<ColorComponent<R2>, ParseError<'i>>, - F3: FnOnce(&P, &mut Parser<'i, 't>, bool) -> Result<ColorComponent<R3>, ParseError<'i>>, + F1: FnOnce( + &ColorParser<'a, 'b>, + &mut Parser<'i, 't>, + bool, + ) -> Result<ColorComponent<R1>, ParseError<'i>>, + F2: FnOnce( + &ColorParser<'a, 'b>, + &mut Parser<'i, 't>, + bool, + ) -> Result<ColorComponent<R2>, ParseError<'i>>, + F3: FnOnce( + &ColorParser<'a, 'b>, + &mut Parser<'i, 't>, + bool, + ) -> Result<ColorComponent<R3>, ParseError<'i>>, { let r1 = f1(color_parser, input, true)?; let r2 = f2(color_parser, input, true)?; @@ -407,6 +426,7 @@ where } /// Either a number or a percentage. +#[derive(Clone, Copy, Debug)] pub enum NumberOrPercentage { /// `<number>`. Number { @@ -432,7 +452,32 @@ impl NumberOrPercentage { } } +impl ColorComponentType for NumberOrPercentage { + fn units() -> CalcUnits { + CalcUnits::PERCENTAGE + } + + fn try_from_token(token: &Token) -> Result<Self, ()> { + Ok(match *token { + Token::Number { value, .. } => Self::Number { value }, + Token::Percentage { unit_value, .. } => Self::Percentage { unit_value }, + _ => { + return Err(()); + }, + }) + } + + fn try_from_leaf(leaf: &SpecifiedLeaf) -> Result<Self, ()> { + Ok(match *leaf { + SpecifiedLeaf::Percentage(unit_value) => Self::Percentage { unit_value }, + SpecifiedLeaf::Number(value) => Self::Number { value }, + _ => return Err(()), + }) + } +} + /// Either an angle or a number. +#[derive(Clone, Copy, Debug)] pub enum NumberOrAngle { /// `<number>`. Number { @@ -457,45 +502,118 @@ impl NumberOrAngle { } } -/// A trait that can be used to hook into how `cssparser` parses color -/// components, with the intention of implementing more complicated behavior. -/// -/// For example, this is used by Servo to support calc() in color. -pub trait ColorParser<'i> { - /// The type that the parser will construct on a successful parse. - type Output: FromParsedColor; - - /// Parse an `<angle>` or `<number>`. - /// - /// Returns the result in degrees. - fn parse_number_or_angle<'t>( +impl ColorComponentType for NumberOrAngle { + fn units() -> CalcUnits { + CalcUnits::ANGLE + } + + fn try_from_token(token: &Token) -> Result<Self, ()> { + Ok(match *token { + Token::Number { value, .. } => Self::Number { value }, + Token::Dimension { + value, ref unit, .. + } => { + let degrees = + SpecifiedAngle::parse_dimension(value, unit, /* from_calc = */ false) + .map(|angle| angle.degrees())?; + + NumberOrAngle::Angle { degrees } + }, + _ => { + return Err(()); + }, + }) + } + + fn try_from_leaf(leaf: &SpecifiedLeaf) -> Result<Self, ()> { + Ok(match *leaf { + SpecifiedLeaf::Angle(angle) => Self::Angle { + degrees: angle.degrees(), + }, + SpecifiedLeaf::Number(value) => Self::Number { value }, + _ => return Err(()), + }) + } +} + +/// The raw f32 here is for <number>. +impl ColorComponentType for f32 { + fn units() -> CalcUnits { + CalcUnits::empty() + } + + fn try_from_token(token: &Token) -> Result<Self, ()> { + if let Token::Number { value, .. } = *token { + Ok(value) + } else { + Err(()) + } + } + + fn try_from_leaf(leaf: &SpecifiedLeaf) -> Result<Self, ()> { + if let SpecifiedLeaf::Number(value) = *leaf { + Ok(value) + } else { + Err(()) + } + } +} + +/// Used to parse the components of a color. +pub struct ColorParser<'a, 'b: 'a> { + /// Parser context used for parsing the colors. + pub context: &'a ParserContext<'b>, +} + +impl<'a, 'b: 'a> ColorParser<'a, 'b> { + /// Parse an `<number>` or `<angle>` value. + fn parse_number_or_angle<'i, 't>( &self, input: &mut Parser<'i, 't>, allow_none: bool, - ) -> Result<ColorComponent<NumberOrAngle>, ParseError<'i>>; + ) -> Result<ColorComponent<NumberOrAngle>, ParseError<'i>> { + ColorComponent::parse(self.context, input, allow_none) + } /// Parse a `<percentage>` value. - /// - /// Returns the result in a number from 0.0 to 1.0. - fn parse_percentage<'t>( + fn parse_percentage<'i, 't>( &self, input: &mut Parser<'i, 't>, allow_none: bool, - ) -> Result<ColorComponent<f32>, ParseError<'i>>; + ) -> Result<ColorComponent<f32>, ParseError<'i>> { + let location = input.current_source_location(); + + // We can use the [NumberOrPercentage] type here, because parsing it + // doesn't have any more overhead than just parsing a percentage on its + // own. + Ok( + match ColorComponent::<NumberOrPercentage>::parse(self.context, input, allow_none)? { + ColorComponent::None => ColorComponent::None, + ColorComponent::Value(NumberOrPercentage::Percentage { unit_value }) => { + ColorComponent::Value(unit_value) + }, + _ => return Err(location.new_custom_error(StyleParseErrorKind::UnspecifiedError)), + }, + ) + } /// Parse a `<number>` value. - fn parse_number<'t>( + fn parse_number<'i, 't>( &self, input: &mut Parser<'i, 't>, allow_none: bool, - ) -> Result<ColorComponent<f32>, ParseError<'i>>; + ) -> Result<ColorComponent<f32>, ParseError<'i>> { + ColorComponent::parse(self.context, input, allow_none) + } - /// Parse a `<number>` value or a `<percentage>` value. - fn parse_number_or_percentage<'t>( + /// Parse a `<number>` or `<percentage>` value. + fn parse_number_or_percentage<'i, 't>( &self, input: &mut Parser<'i, 't>, allow_none: bool, - ) -> Result<ColorComponent<NumberOrPercentage>, ParseError<'i>>; + ) -> Result<ColorComponent<NumberOrPercentage>, ParseError<'i>> { + ColorComponent::parse(self.context, input, allow_none) + } } /// This trait is used by the [`ColorParser`] to construct colors of any type. diff --git a/servo/components/style/context.rs b/servo/components/style/context.rs index a2c020475b..8229721006 100644 --- a/servo/components/style/context.rs +++ b/servo/components/style/context.rs @@ -41,7 +41,6 @@ use style_traits::CSSPixel; use style_traits::DevicePixel; #[cfg(feature = "servo")] use style_traits::SpeculativePainter; -use time; pub use selectors::matching::QuirksMode; diff --git a/servo/components/style/custom_properties.rs b/servo/components/style/custom_properties.rs index b6523dd489..766fe530d9 100644 --- a/servo/components/style/custom_properties.rs +++ b/servo/components/style/custom_properties.rs @@ -125,7 +125,12 @@ macro_rules! lnf_int_variable { }}; } -static CHROME_ENVIRONMENT_VARIABLES: [EnvironmentVariable; 8] = [ +static CHROME_ENVIRONMENT_VARIABLES: [EnvironmentVariable; 9] = [ + lnf_int_variable!( + atom!("-moz-mac-titlebar-height"), + MacTitlebarHeight, + int_pixels + ), lnf_int_variable!( atom!("-moz-gtk-csd-titlebar-button-spacing"), TitlebarButtonSpacing, diff --git a/servo/components/style/dom.rs b/servo/components/style/dom.rs index 358d788845..ec99a796c1 100644 --- a/servo/components/style/dom.rs +++ b/servo/components/style/dom.rs @@ -14,12 +14,12 @@ use crate::context::{PostAnimationTasks, UpdateAnimationsTasks}; use crate::data::ElementData; use crate::media_queries::Device; use crate::properties::{AnimationDeclarations, ComputedValues, PropertyDeclarationBlock}; -use crate::selector_parser::{AttrValue, CustomState, Lang, PseudoElement, SelectorImpl}; +use crate::selector_parser::{AttrValue, Lang, PseudoElement, SelectorImpl}; use crate::shared_lock::{Locked, SharedRwLock}; use crate::stylist::CascadeData; use crate::values::computed::Display; use crate::values::AtomIdent; -use crate::WeakAtom; +use crate::{LocalName, WeakAtom}; use atomic_refcell::{AtomicRef, AtomicRefMut}; use dom::ElementState; use selectors::matching::{ElementSelectorFlags, QuirksMode, VisitedHandlingMode}; @@ -511,11 +511,6 @@ pub trait TElement: /// Get this element's state, for non-tree-structural pseudos. fn state(&self) -> ElementState; - /// Returns whether this element's CustomStateSet contains a given state. - fn has_custom_state(&self, _state: &CustomState) -> bool { - false - } - /// Returns whether this element has a `part` attribute. fn has_part_attr(&self) -> bool; @@ -530,6 +525,11 @@ pub trait TElement: where F: FnMut(&AtomIdent); + /// Internal iterator for the classes of this element. + fn each_custom_state<F>(&self, callback: F) + where + F: FnMut(&AtomIdent); + /// Internal iterator for the part names of this element. fn each_part<F>(&self, _callback: F) where @@ -540,7 +540,7 @@ pub trait TElement: /// Internal iterator for the attribute names of this element. fn each_attr_name<F>(&self, callback: F) where - F: FnMut(&AtomIdent); + F: FnMut(&LocalName); /// Internal iterator for the part names that this element exports for a /// given part name. @@ -906,7 +906,7 @@ pub trait TElement: fn has_selector_flags(&self, flags: ElementSelectorFlags) -> bool; /// Returns the search direction for relative selector invalidation, if it is on the search path. - fn relative_selector_search_direction(&self) -> Option<ElementSelectorFlags>; + fn relative_selector_search_direction(&self) -> ElementSelectorFlags; } /// TNode and TElement aren't Send because we want to be careful and explicit diff --git a/servo/components/style/dom_apis.rs b/servo/components/style/dom_apis.rs index cdc106e1ad..34ea73e5e6 100644 --- a/servo/components/style/dom_apis.rs +++ b/servo/components/style/dom_apis.rs @@ -368,7 +368,7 @@ fn collect_elements_with_id<E, Q, F>( } } -fn has_attr<E>(element: E, local_name: &AtomIdent) -> bool +fn has_attr<E>(element: E, local_name: &crate::LocalName) -> bool where E: TElement, { @@ -396,7 +396,7 @@ where element.local_name() == &**chosen_name } -fn get_attr_name(component: &Component<SelectorImpl>) -> Option<&AtomIdent> { +fn get_attr_name(component: &Component<SelectorImpl>) -> Option<&crate::LocalName> { let (name, name_lower) = match component { Component::AttributeInNoNamespace { ref local_name, .. } => return Some(local_name), Component::AttributeInNoNamespaceExists { @@ -512,7 +512,7 @@ where enum SimpleFilter<'a> { Class(&'a AtomIdent), - Attr(&'a AtomIdent), + Attr(&'a crate::LocalName), LocalName(&'a LocalName<SelectorImpl>), } diff --git a/servo/components/style/driver.rs b/servo/components/style/driver.rs index a2407cb209..59f401895a 100644 --- a/servo/components/style/driver.rs +++ b/servo/components/style/driver.rs @@ -13,9 +13,7 @@ use crate::dom::{SendNode, TElement, TNode}; use crate::parallel; use crate::scoped_tls::ScopedTLS; use crate::traversal::{DomTraversal, PerLevelTraversalData, PreTraverseToken}; -use rayon; use std::collections::VecDeque; -use time; #[cfg(feature = "servo")] fn should_report_statistics() -> bool { @@ -36,14 +34,17 @@ fn report_statistics(_stats: &PerThreadTraversalStatistics) { fn report_statistics(stats: &PerThreadTraversalStatistics) { // This should only be called in the main thread, or it may be racy // to update the statistics in a global variable. - debug_assert!(unsafe { crate::gecko_bindings::bindings::Gecko_IsMainThread() }); - let gecko_stats = - unsafe { &mut crate::gecko_bindings::structs::ServoTraversalStatistics_sSingleton }; - gecko_stats.mElementsTraversed += stats.elements_traversed; - gecko_stats.mElementsStyled += stats.elements_styled; - gecko_stats.mElementsMatched += stats.elements_matched; - gecko_stats.mStylesShared += stats.styles_shared; - gecko_stats.mStylesReused += stats.styles_reused; + unsafe { + debug_assert!(crate::gecko_bindings::bindings::Gecko_IsMainThread()); + let gecko_stats = std::ptr::addr_of_mut!( + crate::gecko_bindings::structs::ServoTraversalStatistics_sSingleton + ); + (*gecko_stats).mElementsTraversed += stats.elements_traversed; + (*gecko_stats).mElementsStyled += stats.elements_styled; + (*gecko_stats).mElementsMatched += stats.elements_matched; + (*gecko_stats).mStylesShared += stats.styles_shared; + (*gecko_stats).mStylesReused += stats.styles_reused; + } } fn with_pool_in_place_scope<'scope>( diff --git a/servo/components/style/gecko/arc_types.rs b/servo/components/style/gecko/arc_types.rs index 24bf22d69a..420b86d332 100644 --- a/servo/components/style/gecko/arc_types.rs +++ b/servo/components/style/gecko/arc_types.rs @@ -16,7 +16,8 @@ use crate::stylesheets::keyframes_rule::Keyframe; use crate::stylesheets::{ ContainerRule, CounterStyleRule, CssRules, DocumentRule, FontFaceRule, FontFeatureValuesRule, FontPaletteValuesRule, ImportRule, KeyframesRule, LayerBlockRule, LayerStatementRule, - MediaRule, NamespaceRule, PageRule, PropertyRule, StyleRule, StylesheetContents, SupportsRule, + MediaRule, NamespaceRule, PageRule, PropertyRule, ScopeRule, StartingStyleRule, StyleRule, + StylesheetContents, SupportsRule, }; use servo_arc::Arc; @@ -169,3 +170,13 @@ impl_simple_arc_ffi!( Servo_AnimationValue_AddRef, Servo_AnimationValue_Release ); +impl_simple_arc_ffi!( + ScopeRule, + Servo_ScopeRule_AddRef, + Servo_ScopeRule_Release +); +impl_simple_arc_ffi!( + StartingStyleRule, + Servo_StartingStyleRule_AddRef, + Servo_StartingStyleRule_Release +); diff --git a/servo/components/style/gecko/media_features.rs b/servo/components/style/gecko/media_features.rs index 8de45d95c2..df1c5e464b 100644 --- a/servo/components/style/gecko/media_features.rs +++ b/servo/components/style/gecko/media_features.rs @@ -8,13 +8,14 @@ use crate::gecko_bindings::bindings; use crate::gecko_bindings::structs; use crate::gecko_bindings::structs::ScreenColorGamut; use crate::media_queries::{Device, MediaType}; -use crate::queries::condition::KleeneValue; +use crate::parser::ParserContext; use crate::queries::feature::{AllowsRanges, Evaluator, FeatureFlags, QueryFeatureDescription}; use crate::queries::values::Orientation; use crate::values::computed::{CSSPixelLength, Context, Ratio, Resolution}; use crate::values::AtomString; use app_units::Au; use euclid::default::Size2D; +use selectors::kleene_value::KleeneValue; fn device_size(device: &Device) -> Size2D<Au> { let mut width = 0; @@ -286,16 +287,26 @@ fn eval_prefers_contrast(context: &Context, query_value: Option<PrefersContrast> pub enum ForcedColors { /// Page colors are not being forced. None, + /// Page colors would be forced in content. + #[parse(condition = "ParserContext::chrome_rules_enabled")] + Requested, /// Page colors are being forced. Active, } +impl ForcedColors { + /// Returns whether forced-colors is active for this page. + pub fn is_active(self) -> bool { + matches!(self, Self::Active) + } +} + /// https://drafts.csswg.org/mediaqueries-5/#forced-colors fn eval_forced_colors(context: &Context, query_value: Option<ForcedColors>) -> bool { - let forced = !context.device().use_document_colors(); + let forced = context.device().forced_colors(); match query_value { - Some(query_value) => forced == (query_value == ForcedColors::Active), - None => forced, + Some(query_value) => query_value == forced, + None => forced != ForcedColors::None, } } diff --git a/servo/components/style/gecko/media_queries.rs b/servo/components/style/gecko/media_queries.rs index ef156ab380..ded66027f2 100644 --- a/servo/components/style/gecko/media_queries.rs +++ b/servo/components/style/gecko/media_queries.rs @@ -29,6 +29,8 @@ use std::sync::atomic::{AtomicBool, AtomicU32, AtomicUsize, Ordering}; use std::{cmp, fmt}; use style_traits::{CSSPixel, DevicePixel}; +use super::media_features::ForcedColors; + /// The `Device` in Gecko wraps a pres context, has a default values computed, /// and contains all the viewport rule state. pub struct Device { @@ -172,10 +174,9 @@ impl Device { Length::new(f32::from_bits(self.root_font_size.load(Ordering::Relaxed))) } - /// Set the font size of the root element (for rem) - pub fn set_root_font_size(&self, size: Length) { - self.root_font_size - .store(size.px().to_bits(), Ordering::Relaxed) + /// Set the font size of the root element (for rem), in zoom-independent CSS pixels. + pub fn set_root_font_size(&self, size: f32) { + self.root_font_size.store(size.to_bits(), Ordering::Relaxed) } /// Get the line height of the root element (for rlh) @@ -186,10 +187,9 @@ impl Device { )) } - /// Set the line height of the root element (for rlh) - pub fn set_root_line_height(&self, size: Length) { - self.root_line_height - .store(size.px().to_bits(), Ordering::Relaxed); + /// Set the line height of the root element (for rlh), in zoom-independent CSS pixels. + pub fn set_root_line_height(&self, size: f32) { + self.root_line_height.store(size.to_bits(), Ordering::Relaxed); } /// The quirks mode of the document. @@ -498,12 +498,27 @@ impl Device { /// Returns whether document colors are enabled. #[inline] - pub fn use_document_colors(&self) -> bool { - let doc = self.document(); - if doc.mIsBeingUsedAsImage() { - return true; + pub fn forced_colors(&self) -> ForcedColors { + if self.document().mIsBeingUsedAsImage() { + // SVG images never force colors. + return ForcedColors::None + } + let prefs = self.pref_sheet_prefs(); + if !prefs.mUseDocumentColors { + return ForcedColors::Active + } + // On Windows, having a high contrast theme also means that the OS is requesting the + // colors to be forced. This is mostly convenience for the front-end, which wants to + // reuse the forced-colors styles for chrome in this case as well, and it's a lot + // more convenient to use `(forced-colors)` than + // `(forced-colors) or ((-moz-platform: windows) and (prefers-contrast))`. + // + // TODO(emilio): We might want to factor in here the lwtheme attribute in the root element + // and so on. + if cfg!(target_os = "windows") && prefs.mUseAccessibilityTheme && prefs.mIsChrome { + return ForcedColors::Requested; } - self.pref_sheet_prefs().mUseDocumentColors + ForcedColors::None } /// Computes a system color and returns it as an nscolor. diff --git a/servo/components/style/gecko/non_ts_pseudo_class_list.rs b/servo/components/style/gecko/non_ts_pseudo_class_list.rs index cc7495dd9c..f628c77ad5 100644 --- a/servo/components/style/gecko/non_ts_pseudo_class_list.rs +++ b/servo/components/style/gecko/non_ts_pseudo_class_list.rs @@ -98,7 +98,6 @@ macro_rules! apply_non_ts_list { // media query results are more expensive than document state changes. So for now // making them pseudo-classes is probably the right trade-off. ("-moz-is-html", MozIsHTML, _, PSEUDO_CLASS_ENABLED_IN_UA_SHEETS), - ("-moz-lwtheme", MozLWTheme, _, PSEUDO_CLASS_ENABLED_IN_UA_SHEETS_AND_CHROME), ("-moz-window-inactive", MozWindowInactive, _, _), ] } diff --git a/servo/components/style/gecko/pseudo_element.rs b/servo/components/style/gecko/pseudo_element.rs index 3bcd873455..f0e79a8acd 100644 --- a/servo/components/style/gecko/pseudo_element.rs +++ b/servo/components/style/gecko/pseudo_element.rs @@ -159,6 +159,11 @@ impl PseudoElement { matches!(*self, Self::Highlight(_)) } + /// Whether this pseudo-element is the ::target-text pseudo. + #[inline] + pub fn is_target_text(&self) -> bool { + *self == PseudoElement::TargetText + } /// Whether this pseudo-element supports user action selectors. pub fn supports_user_action_state(&self) -> bool { (self.flags() & structs::CSS_PSEUDO_ELEMENT_SUPPORTS_USER_ACTION_STATE) != 0 @@ -168,6 +173,7 @@ impl PseudoElement { pub fn enabled_in_content(&self) -> bool { match *self { Self::Highlight(..) => pref!("dom.customHighlightAPI.enabled"), + Self::TargetText => pref!("dom.text_fragments.enabled"), Self::SliderFill | Self::SliderTrack | Self::SliderThumb => { pref!("layout.css.modern-range-pseudos.enabled") }, diff --git a/servo/components/style/gecko/selector_parser.rs b/servo/components/style/gecko/selector_parser.rs index 203e6a3609..100bb45e81 100644 --- a/servo/components/style/gecko/selector_parser.rs +++ b/servo/components/style/gecko/selector_parser.rs @@ -196,7 +196,6 @@ impl NonTSPseudoClass { None => DocumentState::empty(), }, NonTSPseudoClass::MozWindowInactive => DocumentState::WINDOW_INACTIVE, - NonTSPseudoClass::MozLWTheme => DocumentState::LWTHEME, _ => DocumentState::empty(), } } @@ -214,11 +213,10 @@ impl NonTSPseudoClass { NonTSPseudoClass::MozNativeAnonymous | // :-moz-placeholder is parsed but never matches. NonTSPseudoClass::MozPlaceholder | - // :-moz-is-html, :-moz-lwtheme, :-moz-locale-dir and :-moz-window-inactive + // :-moz-is-html, :-moz-locale-dir and :-moz-window-inactive // depend only on the state of the document, which is invariant across all // elements involved in a given style cache. NonTSPseudoClass::MozIsHTML | - NonTSPseudoClass::MozLWTheme | NonTSPseudoClass::MozLocaleDir(_) | NonTSPseudoClass::MozWindowInactive ) diff --git a/servo/components/style/gecko/snapshot.rs b/servo/components/style/gecko/snapshot.rs index 2ff04406ac..8f6eb120d5 100644 --- a/servo/components/style/gecko/snapshot.rs +++ b/servo/components/style/gecko/snapshot.rs @@ -171,4 +171,33 @@ impl ElementSnapshot for GeckoElementSnapshot { Some(AtomString(unsafe { Atom::from_addrefed(ptr) })) } } + + /// Returns true if the snapshot has stored state for custom states + #[inline] + fn has_custom_states(&self) -> bool { + self.has_any(Flags::CustomState) + } + + /// Returns true if the snapshot has a given CustomState + #[inline] + fn has_custom_state(&self, state: &AtomIdent) -> bool { + unsafe { + self.mCustomStates.iter().any(|setstate| { + AtomIdent::with(setstate.mRawPtr, |setstate| state == setstate) + }) + } + } + + #[inline] + fn each_custom_state<F>(&self, mut callback: F) + where + F: FnMut(&AtomIdent), + { + unsafe { + for atom in self.mCustomStates.iter() { + AtomIdent::with(atom.mRawPtr, &mut callback) + } + } + } + } diff --git a/servo/components/style/gecko/url.rs b/servo/components/style/gecko/url.rs index 7fe32acc20..fa8d22adb6 100644 --- a/servo/components/style/gecko/url.rs +++ b/servo/components/style/gecko/url.rs @@ -18,7 +18,7 @@ use std::fmt::{self, Write}; use std::mem::ManuallyDrop; use std::sync::RwLock; use style_traits::{CssWriter, ParseError, ToCss}; -use to_shmem::{self, SharedMemoryBuilder, ToShmem}; +use to_shmem::{SharedMemoryBuilder, ToShmem}; /// A CSS url() value for gecko. #[derive(Clone, Debug, PartialEq, SpecifiedValueInfo, ToCss, ToShmem)] diff --git a/servo/components/style/gecko/wrapper.rs b/servo/components/style/gecko/wrapper.rs index 43cf6e7941..eab968149c 100644 --- a/servo/components/style/gecko/wrapper.rs +++ b/servo/components/style/gecko/wrapper.rs @@ -19,7 +19,7 @@ use crate::bloom::each_relevant_element_hash; use crate::context::{PostAnimationTasks, QuirksMode, SharedStyleContext, UpdateAnimationsTasks}; use crate::data::ElementData; use crate::dom::{LayoutIterator, NodeInfo, OpaqueNode, TDocument, TElement, TNode, TShadowRoot}; -use crate::gecko::selector_parser::{CustomState, NonTSPseudoClass, PseudoElement, SelectorImpl}; +use crate::gecko::selector_parser::{NonTSPseudoClass, PseudoElement, SelectorImpl}; use crate::gecko::snapshot_helpers; use crate::gecko_bindings::bindings; use crate::gecko_bindings::bindings::Gecko_ElementHasAnimations; @@ -889,7 +889,11 @@ impl<'le> GeckoElement<'le> { AnimationValue::from_computed_values(property_declaration_id, before_change_style); let to = AnimationValue::from_computed_values(property_declaration_id, after_change_style); - debug_assert_eq!(to.is_some(), from.is_some()); + // If the declaration contains a custom property and getComputedValue was previously called + // before that custom property was defined, `from` will be `None` here. + debug_assert!( + to.is_some() == from.is_some() || matches!(to, Some(AnimationValue::Custom(..))) + ); from != to } @@ -1237,20 +1241,6 @@ impl<'le> TElement for GeckoElement<'le> { } #[inline] - fn has_custom_state(&self, state: &CustomState) -> bool { - if !self.is_html_element() { - return false; - } - let check_state_ptr: *const nsAtom = state.0.as_ptr(); - self.extended_slots().map_or(false, |slot| { - (&slot.mCustomStates).iter().any(|setstate| { - let setstate_ptr: *const nsAtom = setstate.mRawPtr; - setstate_ptr == check_state_ptr - }) - }) - } - - #[inline] fn has_part_attr(&self) -> bool { self.as_node() .get_bool_flag(nsINode_BooleanFlag::ElementHasPart) @@ -1292,6 +1282,20 @@ impl<'le> TElement for GeckoElement<'le> { } #[inline] + fn each_custom_state<F>(&self, mut callback: F) + where + F: FnMut(&AtomIdent), + { + if let Some(slots) = self.extended_slots() { + unsafe { + for atom in slots.mCustomStates.iter() { + AtomIdent::with(atom.mRawPtr, &mut callback) + } + } + } + } + + #[inline] fn each_exported_part<F>(&self, name: &AtomIdent, callback: F) where F: FnMut(&AtomIdent), @@ -1551,14 +1555,13 @@ impl<'le> TElement for GeckoElement<'le> { let mut transitions_to_keep = PropertyDeclarationIdSet::default(); for transition_property in after_change_style.transition_properties() { - let physical_longhand = PropertyDeclarationId::Longhand( - transition_property - .longhand_id - .to_physical(after_change_style.writing_mode), - ); - transitions_to_keep.insert(physical_longhand); + let physical_property = transition_property + .property + .as_borrowed() + .to_physical(after_change_style.writing_mode); + transitions_to_keep.insert(physical_property); if self.needs_transitions_update_per_property( - physical_longhand, + physical_property, after_change_ui_style .transition_combined_duration_at(transition_property.index) .seconds(), @@ -1791,17 +1794,17 @@ impl<'le> TElement for GeckoElement<'le> { self.as_node().selector_flags() & node_flags == node_flags } - fn relative_selector_search_direction(&self) -> Option<ElementSelectorFlags> { + fn relative_selector_search_direction(&self) -> ElementSelectorFlags { use crate::gecko_bindings::structs::NodeSelectorFlags; let flags = self.as_node().selector_flags(); if (flags & NodeSelectorFlags::RelativeSelectorSearchDirectionAncestorSibling.0) != 0 { - Some(ElementSelectorFlags::RELATIVE_SELECTOR_SEARCH_DIRECTION_ANCESTOR_SIBLING) + ElementSelectorFlags::RELATIVE_SELECTOR_SEARCH_DIRECTION_ANCESTOR_SIBLING } else if (flags & NodeSelectorFlags::RelativeSelectorSearchDirectionAncestor.0) != 0 { - Some(ElementSelectorFlags::RELATIVE_SELECTOR_SEARCH_DIRECTION_ANCESTOR) + ElementSelectorFlags::RELATIVE_SELECTOR_SEARCH_DIRECTION_ANCESTOR } else if (flags & NodeSelectorFlags::RelativeSelectorSearchDirectionSibling.0) != 0 { - Some(ElementSelectorFlags::RELATIVE_SELECTOR_SEARCH_DIRECTION_SIBLING) + ElementSelectorFlags::RELATIVE_SELECTOR_SEARCH_DIRECTION_SIBLING } else { - None + ElementSelectorFlags::empty() } } } @@ -2042,15 +2045,14 @@ impl<'le> ::selectors::Element for GeckoElement<'le> { NonTSPseudoClass::MozAutofillPreview | NonTSPseudoClass::MozRevealed | NonTSPseudoClass::MozValueEmpty => self.state().intersects(pseudo_class.state_flag()), - // TODO: This applying only to HTML elements is weird. NonTSPseudoClass::Dir(ref dir) => { - self.is_html_element() && self.state().intersects(dir.element_state()) + self.state().intersects(dir.element_state()) }, NonTSPseudoClass::AnyLink => self.is_link(), NonTSPseudoClass::Link => { self.is_link() && context.visited_handling().matches_unvisited() }, - NonTSPseudoClass::CustomState(ref state) => self.has_custom_state(state), + NonTSPseudoClass::CustomState(ref state) => self.has_custom_state(&state.0), NonTSPseudoClass::Visited => { self.is_link() && context.visited_handling().matches_visited() }, @@ -2101,7 +2103,6 @@ impl<'le> ::selectors::Element for GeckoElement<'le> { bindings::Gecko_IsSelectListBox(self.0) }, NonTSPseudoClass::MozIsHTML => self.as_node().owner_doc().is_html_document(), - NonTSPseudoClass::MozLWTheme | NonTSPseudoClass::MozLocaleDir(..) | NonTSPseudoClass::MozWindowInactive => { let state_bit = pseudo_class.document_state_flag(); @@ -2186,6 +2187,20 @@ impl<'le> ::selectors::Element for GeckoElement<'le> { } #[inline] + fn has_custom_state(&self, state: &AtomIdent) -> bool { + if !self.is_html_element() { + return false; + } + let check_state_ptr: *const nsAtom = state.as_ptr(); + self.extended_slots().map_or(false, |slot| { + (&slot.mCustomStates).iter().any(|setstate| { + let setstate_ptr: *const nsAtom = setstate.mRawPtr; + setstate_ptr == check_state_ptr + }) + }) + } + + #[inline] fn is_html_element_in_html_document(&self) -> bool { self.is_html_element() && self.as_node().owner_doc().is_html_document() } diff --git a/servo/components/style/gecko_bindings/sugar/ns_style_auto_array.rs b/servo/components/style/gecko_bindings/sugar/ns_style_auto_array.rs index b5772a6c77..350d578001 100644 --- a/servo/components/style/gecko_bindings/sugar/ns_style_auto_array.rs +++ b/servo/components/style/gecko_bindings/sugar/ns_style_auto_array.rs @@ -11,7 +11,7 @@ use crate::gecko_bindings::bindings::Gecko_EnsureStyleViewTimelineArrayLength; use crate::gecko_bindings::structs::nsStyleAutoArray; use crate::gecko_bindings::structs::{StyleAnimation, StyleTransition}; use crate::gecko_bindings::structs::{StyleScrollTimeline, StyleViewTimeline}; -use std::iter::{once, Chain, IntoIterator, Once}; +use std::iter::{once, Chain, Once}; use std::ops::{Index, IndexMut}; use std::slice::{Iter, IterMut}; diff --git a/servo/components/style/gecko_string_cache/mod.rs b/servo/components/style/gecko_string_cache/mod.rs index 79a5d46525..3640b61d11 100644 --- a/servo/components/style/gecko_string_cache/mod.rs +++ b/servo/components/style/gecko_string_cache/mod.rs @@ -28,7 +28,7 @@ use std::num::NonZeroUsize; use std::ops::Deref; use std::{slice, str}; use style_traits::SpecifiedValueInfo; -use to_shmem::{self, SharedMemoryBuilder, ToShmem}; +use to_shmem::{SharedMemoryBuilder, ToShmem}; #[macro_use] #[allow(improper_ctypes, non_camel_case_types, missing_docs)] diff --git a/servo/components/style/global_style_data.rs b/servo/components/style/global_style_data.rs index 38d72b2c74..d6e49e7da6 100644 --- a/servo/components/style/global_style_data.rs +++ b/servo/components/style/global_style_data.rs @@ -10,9 +10,7 @@ use crate::gecko_bindings::bindings; use crate::parallel::STYLE_THREAD_STACK_SIZE_KB; use crate::shared_lock::SharedRwLock; use crate::thread_state; -use gecko_profiler; use parking_lot::{Mutex, RwLock, RwLockReadGuard}; -use rayon; #[cfg(unix)] use std::os::unix::thread::{JoinHandleExt, RawPthread}; #[cfg(windows)] diff --git a/servo/components/style/invalidation/element/element_wrapper.rs b/servo/components/style/invalidation/element/element_wrapper.rs index e17afd7774..9a39b7d5a0 100644 --- a/servo/components/style/invalidation/element/element_wrapper.rs +++ b/servo/components/style/invalidation/element/element_wrapper.rs @@ -73,6 +73,18 @@ pub trait ElementSnapshot: Sized { where F: FnMut(&AtomIdent); + + /// If this snapshot contains CustomStateSet information. + fn has_custom_states(&self) -> bool; + + /// A callback that should be called for each CustomState of the snapshot. + fn has_custom_state(&self, state: &AtomIdent) -> bool; + + /// A callback that should be called for each CustomState of the snapshot. + fn each_custom_state<F>(&self, callback: F) + where + F: FnMut(&AtomIdent); + /// The `xml:lang=""` or `lang=""` attribute value per this snapshot. fn lang_attr(&self) -> Option<AttrValue>; } @@ -213,6 +225,11 @@ where .match_element_lang(Some(self.get_lang()), lang_arg); }, + // CustomStateSet should match against the snapshot before element + NonTSPseudoClass::CustomState(ref state) => { + return self.has_custom_state(&state.0) + }, + _ => {}, } @@ -357,6 +374,13 @@ where } } + fn has_custom_state(&self, state: &AtomIdent) -> bool { + match self.snapshot() { + Some(snapshot) if snapshot.has_custom_states() => snapshot.has_custom_state(state), + _ => self.element.has_custom_state(state), + } + } + fn is_empty(&self) -> bool { self.element.is_empty() } diff --git a/servo/components/style/invalidation/element/invalidation_map.rs b/servo/components/style/invalidation/element/invalidation_map.rs index cb03862740..f42f542dd2 100644 --- a/servo/components/style/invalidation/element/invalidation_map.rs +++ b/servo/components/style/invalidation/element/invalidation_map.rs @@ -10,6 +10,7 @@ use crate::selector_map::{ }; use crate::selector_parser::{NonTSPseudoClass, SelectorImpl}; use crate::AllocErr; +use crate::values::AtomIdent; use crate::{Atom, LocalName, Namespace, ShrinkIfNeeded}; use dom::{DocumentState, ElementState}; use selectors::attr::NamespaceConstraint; @@ -259,6 +260,8 @@ pub type IdOrClassDependencyMap = MaybeCaseInsensitiveHashMap<Atom, SmallVec<[De pub type StateDependencyMap = SelectorMap<StateDependency>; /// Dependency mapping for local names. pub type LocalNameDependencyMap = PrecomputedHashMap<LocalName, SmallVec<[Dependency; 1]>>; +/// Dependency mapping for customstates +pub type CustomStateDependencyMap = PrecomputedHashMap<AtomIdent, SmallVec<[Dependency; 1]>>; /// A map where we store invalidations. /// @@ -282,6 +285,8 @@ pub struct InvalidationMap { pub document_state_selectors: Vec<DocumentStateDependency>, /// A map of other attribute affecting selectors. pub other_attribute_affecting_selectors: LocalNameDependencyMap, + /// A map of CSS custom states + pub custom_state_affecting_selectors: CustomStateDependencyMap, } /// Tree-structural pseudoclasses that we care about for (Relative selector) invalidation. @@ -383,6 +388,7 @@ impl InvalidationMap { state_affecting_selectors: StateDependencyMap::new(), document_state_selectors: Vec::new(), other_attribute_affecting_selectors: LocalNameDependencyMap::default(), + custom_state_affecting_selectors: CustomStateDependencyMap::default(), } } @@ -398,6 +404,9 @@ impl InvalidationMap { .fold(0, |accum, (_, ref v)| accum + v.len()) + self.class_to_selector .iter() + .fold(0, |accum, (_, ref v)| accum + v.len()) + + self.custom_state_affecting_selectors + .iter() .fold(0, |accum, (_, ref v)| accum + v.len()) } @@ -408,6 +417,7 @@ impl InvalidationMap { self.state_affecting_selectors.clear(); self.document_state_selectors.clear(); self.other_attribute_affecting_selectors.clear(); + self.custom_state_affecting_selectors.clear(); } /// Shrink the capacity of hash maps if needed. @@ -416,6 +426,7 @@ impl InvalidationMap { self.id_to_selector.shrink_if_needed(); self.state_affecting_selectors.shrink_if_needed(); self.other_attribute_affecting_selectors.shrink_if_needed(); + self.custom_state_affecting_selectors.shrink_if_needed(); } } @@ -489,6 +500,7 @@ trait Collector { fn class_map(&mut self) -> &mut IdOrClassDependencyMap; fn state_map(&mut self) -> &mut StateDependencyMap; fn attribute_map(&mut self) -> &mut LocalNameDependencyMap; + fn custom_state_map(&mut self) -> &mut LocalNameDependencyMap; fn update_states(&mut self, element_state: ElementState, document_state: DocumentState); // In normal invalidations, type-based dependencies don't need to be explicitly tracked; @@ -551,6 +563,16 @@ fn add_attr_dependency<C: Collector>(name: LocalName, collector: &mut C) -> Resu add_local_name(name, dependency, map) } +fn add_custom_state_dependency<C: Collector>(name: AtomIdent, collector: &mut C) -> Result<(), AllocErr> { + let dependency = collector.dependency(); + let map = collector.custom_state_map(); + map.try_reserve(1)?; + let vec = map.entry(name).or_default(); + vec.try_reserve(1)?; + vec.push(dependency); + Ok(()) +} + fn add_local_name( name: LocalName, dependency: Dependency, @@ -576,6 +598,9 @@ fn on_pseudo_class<C: Collector>(pc: &NonTSPseudoClass, collector: &mut C) -> Re return add_attr_dependency(local_name!("size"), collector); }, NonTSPseudoClass::Lang(..) => local_name!("lang"), + NonTSPseudoClass::CustomState(ref name) => { + return add_custom_state_dependency(name.0.clone(), collector); + }, _ => return Ok(()), }; @@ -702,6 +727,10 @@ impl<'a> Collector for SelectorDependencyCollector<'a> { self.compound_state.element_state |= element_state; *self.document_state |= document_state; } + + fn custom_state_map(&mut self) -> &mut CustomStateDependencyMap { + &mut self.map.custom_state_affecting_selectors + } } impl<'a> SelectorDependencyCollector<'a> { @@ -1074,6 +1103,10 @@ impl<'a> Collector for RelativeSelectorDependencyCollector<'a> { &mut self.map.map.other_attribute_affecting_selectors } + fn custom_state_map(&mut self) -> &mut CustomStateDependencyMap { + &mut self.map.map.custom_state_affecting_selectors + } + fn update_states(&mut self, element_state: ElementState, document_state: DocumentState) { self.compound_state.state.element_state |= element_state; *self.document_state |= document_state; @@ -1255,6 +1288,10 @@ impl<'a, 'b> Collector for RelativeSelectorInnerDependencyCollector<'a, 'b> { &mut self.map.map.other_attribute_affecting_selectors } + fn custom_state_map(&mut self) -> &mut CustomStateDependencyMap { + &mut self.map.map.custom_state_affecting_selectors + } + fn update_states(&mut self, element_state: ElementState, document_state: DocumentState) { self.compound_state.state.element_state |= element_state; *self.document_state |= document_state; diff --git a/servo/components/style/invalidation/element/relative_selector.rs b/servo/components/style/invalidation/element/relative_selector.rs index ccb48e349f..41222304be 100644 --- a/servo/components/style/invalidation/element/relative_selector.rs +++ b/servo/components/style/invalidation/element/relative_selector.rs @@ -53,12 +53,12 @@ impl DomMutationOperation { fn accept<E: TElement>(&self, d: &Dependency, e: E) -> bool { match self { Self::Insert | Self::Append | Self::Remove => { - e.relative_selector_search_direction().is_some() + !e.relative_selector_search_direction().is_empty() }, // `:has(+ .a + .b)` with `.anchor + .a + .remove + .b` - `.a` would be present // in the search path. Self::SideEffectPrevSibling => { - e.relative_selector_search_direction().is_some() && + !e.relative_selector_search_direction().is_empty() && d.right_combinator_is_next_sibling() }, // If an element is being removed and would cause next-sibling match to happen, @@ -499,6 +499,19 @@ where }, None => (), }); + element.each_custom_state(|v| { + match map.map.custom_state_affecting_selectors.get(v) { + Some(v) => { + for dependency in v { + if !operation.accept(dependency, element) { + continue; + } + self.add_dependency(dependency, element, scope); + } + }, + None => (), + } + }); element.each_attr_name( |v| match map.map.other_attribute_affecting_selectors.get(v) { Some(v) => { @@ -782,11 +795,7 @@ where /// Is this element in the direction of the given relative selector search path? fn in_search_direction(element: &E, desired: ElementSelectorFlags) -> bool { - if let Some(direction) = element.relative_selector_search_direction() { - direction.intersects(desired) - } else { - false - } + element.relative_selector_search_direction().intersects(desired) } /// Handle a potential relative selector anchor. @@ -1145,7 +1154,7 @@ where dep: &'a Dependency, ) { debug_assert!(dep.parent.is_some(), "Orphaned inners selector?"); - if element.relative_selector_search_direction().is_none() { + if element.relative_selector_search_direction().is_empty() { return; } self.invalidations.push(( diff --git a/servo/components/style/invalidation/element/state_and_attributes.rs b/servo/components/style/invalidation/element/state_and_attributes.rs index 1c58cddf1e..d5f0723d66 100644 --- a/servo/components/style/invalidation/element/state_and_attributes.rs +++ b/servo/components/style/invalidation/element/state_and_attributes.rs @@ -19,11 +19,12 @@ use crate::selector_map::SelectorMap; use crate::selector_parser::Snapshot; use crate::stylesheets::origin::OriginSet; use crate::{Atom, WeakAtom}; +use crate::values::AtomIdent; use dom::ElementState; use selectors::attr::CaseSensitivity; +use selectors::kleene_value::KleeneValue; use selectors::matching::{ - matches_selector, MatchingContext, MatchingForInvalidation, MatchingMode, NeedsSelectorFlags, - SelectorCaches, VisitedHandlingMode, + matches_selector_kleene, MatchingContext, MatchingForInvalidation, MatchingMode, NeedsSelectorFlags, SelectorCaches, VisitedHandlingMode }; use smallvec::SmallVec; @@ -41,6 +42,8 @@ where added_id: Option<&'a WeakAtom>, classes_removed: &'a SmallVec<[Atom; 8]>, classes_added: &'a SmallVec<[Atom; 8]>, + custom_states_removed: &'a SmallVec<[AtomIdent; 8]>, + custom_states_added: &'a SmallVec<[AtomIdent; 8]>, state_changes: ElementState, descendant_invalidations: &'a mut DescendantInvalidationLists<'selectors>, sibling_invalidations: &'a mut InvalidationVector<'selectors>, @@ -97,23 +100,25 @@ where E: TElement, W: selectors::Element<Impl = E::Impl>, { - let matches_now = matches_selector( - &dependency.selector, - dependency.selector_offset, - None, - element, - context, - ); + context.for_invalidation_comparison(|context| { + let matches_now = matches_selector_kleene( + &dependency.selector, + dependency.selector_offset, + None, + element, + context, + ); - let matched_then = matches_selector( - &dependency.selector, - dependency.selector_offset, - None, - wrapper, - context, - ); + let matched_then = matches_selector_kleene( + &dependency.selector, + dependency.selector_offset, + None, + wrapper, + context, + ); - matched_then != matches_now + matched_then != matches_now || matches_now == KleeneValue::Unknown + }) } /// Whether we should process the descendants of a given element for style @@ -243,7 +248,7 @@ where return false; }; - if !snapshot.has_attrs() && state_changes.is_empty() { + if !snapshot.has_attrs() && !snapshot.has_custom_states() && state_changes.is_empty() { return false; } @@ -264,6 +269,21 @@ where }) } + let mut custom_states_removed = SmallVec::<[AtomIdent; 8]>::new(); + let mut custom_states_added = SmallVec::<[AtomIdent; 8]>::new(); + if snapshot.has_custom_states() { + snapshot.each_custom_state(|s| { + if !element.has_custom_state(s) { + custom_states_removed.push(s.clone()) + } + }); + element.each_custom_state(|s| { + if !snapshot.has_custom_state(s) { + custom_states_added.push(s.clone()) + } + }) + } + let mut id_removed = None; let mut id_added = None; if snapshot.id_changed() { @@ -326,6 +346,8 @@ where added_id: id_added, classes_removed: &classes_removed, classes_added: &classes_added, + custom_states_removed: &custom_states_removed, + custom_states_added: &custom_states_added, descendant_invalidations, sibling_invalidations, invalidates_self: false, @@ -443,6 +465,14 @@ where } } + for state in self.custom_states_added.iter().chain(self.custom_states_removed.iter()) { + if let Some(deps) = map.custom_state_affecting_selectors.get(state) { + for dep in deps { + self.scan_dependency(dep); + } + } + } + self.snapshot.each_attr_changed(|attribute| { if let Some(deps) = map.other_attribute_affecting_selectors.get(attribute) { for dep in deps { diff --git a/servo/components/style/invalidation/stylesheets.rs b/servo/components/style/invalidation/stylesheets.rs index d845897aa4..48ef8c1b5d 100644 --- a/servo/components/style/invalidation/stylesheets.rs +++ b/servo/components/style/invalidation/stylesheets.rs @@ -616,7 +616,7 @@ impl StylesheetInvalidationSet { return self.invalidate_fully(); }, Document(..) | Import(..) | Media(..) | Supports(..) | Container(..) | - LayerBlock(..) => { + LayerBlock(..) | StartingStyle(..) => { // Do nothing, relevant nested rules are visited as part of rule iteration. }, FontFace(..) => { @@ -646,6 +646,11 @@ impl StylesheetInvalidationSet { debug!(" > Found unsupported rule, marking the whole subtree invalid."); self.invalidate_fully(); }, + Scope(..) => { + // Addition/removal of @scope requires re-evaluation of scope proximity to properly + // figure out the styling order. + self.invalidate_fully(); + }, } } } diff --git a/servo/components/style/matching.rs b/servo/components/style/matching.rs index 646d08a9e3..e9d754aa10 100644 --- a/servo/components/style/matching.rs +++ b/servo/components/style/matching.rs @@ -934,7 +934,8 @@ pub trait MatchMethods: TElement { if old_font_size != Some(new_font_size) { if is_root { debug_assert!(self.owner_doc_matches_for_testing(device)); - device.set_root_font_size(new_font_size.computed_size().into()); + let size = new_font_size.computed_size(); + device.set_root_font_size(new_primary_style.effective_zoom.unzoom(size.px())); if device.used_root_font_size() { // If the root font-size changed since last time, and something // in the document did use rem units, ensure we recascade the @@ -954,7 +955,8 @@ pub trait MatchMethods: TElement { } } - // For line-height, we want the fully resolved value, as `normal` also depends on other font properties. + // For line-height, we want the fully resolved value, as `normal` also depends on other + // font properties. let new_line_height = device .calc_line_height( &new_primary_style.get_font(), @@ -968,14 +970,12 @@ pub trait MatchMethods: TElement { .0 }); - if restyle_requirement != ChildRestyleRequirement::MustMatchDescendants && - old_line_height != Some(new_line_height) - { + if old_line_height != Some(new_line_height) { if is_root { debug_assert!(self.owner_doc_matches_for_testing(device)); - device.set_root_line_height(new_line_height.into()); + device.set_root_line_height(new_primary_style.effective_zoom.unzoom(new_line_height.px())); if device.used_root_line_height() { - restyle_requirement = ChildRestyleRequirement::MustCascadeDescendants; + restyle_requirement = std::cmp::max(restyle_requirement, ChildRestyleRequirement::MustCascadeDescendants); } } diff --git a/servo/components/style/media_queries/media_list.rs b/servo/components/style/media_queries/media_list.rs index 3c2ba9ee5c..7cbbeb5e3e 100644 --- a/servo/components/style/media_queries/media_list.rs +++ b/servo/components/style/media_queries/media_list.rs @@ -10,10 +10,10 @@ use super::{Device, MediaQuery, Qualifier}; use crate::context::QuirksMode; use crate::error_reporting::ContextualParseError; use crate::parser::ParserContext; -use crate::queries::condition::KleeneValue; use crate::values::computed; use cssparser::{Delimiter, Parser}; use cssparser::{ParserInput, Token}; +use selectors::kleene_value::KleeneValue; /// A type that encapsulates a media query list. #[derive(Clone, MallocSizeOf, ToCss, ToShmem)] diff --git a/servo/components/style/parallel.rs b/servo/components/style/parallel.rs index 0b2ccf46d1..0e1c509ab7 100644 --- a/servo/components/style/parallel.rs +++ b/servo/components/style/parallel.rs @@ -26,7 +26,6 @@ use crate::context::{StyleContext, ThreadLocalStyleContext}; use crate::dom::{OpaqueNode, SendNode, TElement}; use crate::scoped_tls::ScopedTLS; use crate::traversal::{DomTraversal, PerLevelTraversalData}; -use rayon; use std::collections::VecDeque; /// The minimum stack size for a thread in the styling pool, in kilobytes. diff --git a/servo/components/style/parser.rs b/servo/components/style/parser.rs index 893625854f..1e339841a9 100644 --- a/servo/components/style/parser.rs +++ b/servo/components/style/parser.rs @@ -9,9 +9,64 @@ use crate::error_reporting::{ContextualParseError, ParseErrorReporter}; use crate::stylesheets::{CssRuleType, CssRuleTypes, Namespaces, Origin, UrlExtraData}; use crate::use_counters::UseCounters; use cssparser::{Parser, SourceLocation, UnicodeRange}; +use selectors::parser::ParseRelative; use std::borrow::Cow; use style_traits::{OneOrMoreSeparated, ParseError, ParsingMode, Separator}; +/// Nesting context for parsing rules. +#[derive(Clone, Copy)] +pub struct NestingContext { + /// All rule types we've nested into, if any. + pub rule_types: CssRuleTypes, + /// Whether or not parsing relative selector syntax should be allowed. + pub parse_relative: ParseRelative, +} + +impl NestingContext { + fn parse_relative_for(rule_type: CssRuleType) -> ParseRelative { + match rule_type { + CssRuleType::Scope => ParseRelative::ForScope, + CssRuleType::Style => ParseRelative::ForNesting, + _ => ParseRelative::No, + } + } + + /// Create a new nesting context. + pub fn new(rule_types: CssRuleTypes, parse_nested_rule_type: Option<CssRuleType>) -> Self { + Self { + rule_types, + parse_relative: parse_nested_rule_type + .map_or(ParseRelative::No, Self::parse_relative_for) + } + } + + /// Create a new nesting context based on the given rule. + pub fn new_from_rule(rule_type: Option<CssRuleType>) -> Self { + Self { + rule_types: rule_type.map(CssRuleTypes::from).unwrap_or_default(), + parse_relative: rule_type + .map(Self::parse_relative_for) + .unwrap_or(ParseRelative::No), + } + } + + /// Save the current nesting context. + pub fn save(&mut self, rule_type: CssRuleType) -> Self { + let old = *self; + self.rule_types.insert(rule_type); + let new_parse_relative = Self::parse_relative_for(rule_type); + if new_parse_relative != ParseRelative::No { + self.parse_relative = new_parse_relative; + } + old + } + + /// Load the saved nesting context. + pub fn restore(&mut self, saved: Self) { + *self = saved; + } +} + /// The data that the parser needs from outside in order to parse a stylesheet. pub struct ParserContext<'a> { /// The `Origin` of the stylesheet, whether it's a user, author or @@ -19,8 +74,6 @@ pub struct ParserContext<'a> { pub stylesheet_origin: Origin, /// The extra data we need for resolving url values. pub url_data: &'a UrlExtraData, - /// The current rule types, if any. - pub rule_types: CssRuleTypes, /// The mode to use when parsing. pub parsing_mode: ParsingMode, /// The quirks mode of this stylesheet. @@ -31,6 +84,8 @@ pub struct ParserContext<'a> { pub namespaces: Cow<'a, Namespaces>, /// The use counters we want to record while parsing style rules, if any. pub use_counters: Option<&'a UseCounters>, + /// Current nesting context. + pub nesting_context: NestingContext, } impl<'a> ParserContext<'a> { @@ -49,12 +104,12 @@ impl<'a> ParserContext<'a> { Self { stylesheet_origin, url_data, - rule_types: rule_type.map(CssRuleTypes::from).unwrap_or_default(), parsing_mode, quirks_mode, error_reporter, namespaces, use_counters, + nesting_context: NestingContext::new_from_rule(rule_type), } } @@ -64,22 +119,21 @@ impl<'a> ParserContext<'a> { rule_type: CssRuleType, cb: impl FnOnce(&mut Self) -> R, ) -> R { - let old_rule_types = self.rule_types; - self.rule_types.insert(rule_type); + let old = self.nesting_context.save(rule_type); let r = cb(self); - self.rule_types = old_rule_types; + self.nesting_context.restore(old); r } /// Whether we're in a @page rule. #[inline] pub fn in_page_rule(&self) -> bool { - self.rule_types.contains(CssRuleType::Page) + self.nesting_context.rule_types.contains(CssRuleType::Page) } /// Get the rule type, which assumes that one is available. pub fn rule_types(&self) -> CssRuleTypes { - self.rule_types + self.nesting_context.rule_types } /// Returns whether CSS error reporting is enabled. diff --git a/servo/components/style/properties/build.py b/servo/components/style/properties/build.py index 42121a4eae..d1f76d4a25 100644 --- a/servo/components/style/properties/build.py +++ b/servo/components/style/properties/build.py @@ -20,36 +20,10 @@ RE_PYTHON_ADDR = re.compile(r"<.+? object at 0x[0-9a-fA-F]+>") OUT_DIR = os.environ.get("OUT_DIR", "") -STYLE_STRUCT_LIST = [ - "background", - "border", - "box", - "column", - "counters", - "effects", - "font", - "inherited_box", - "inherited_svg", - "inherited_table", - "inherited_text", - "inherited_ui", - "list", - "margin", - "outline", - "page", - "padding", - "position", - "svg", - "table", - "text", - "ui", - "xul", -] - def main(): usage = ( - "Usage: %s [ servo-2013 | servo-2020 | gecko ] [ style-crate | geckolib <template> | html ]" + "Usage: %s [ servo | gecko ] [ style-crate | geckolib <template> ]" % sys.argv[0] ) if len(sys.argv) < 3: @@ -57,29 +31,15 @@ def main(): engine = sys.argv[1] output = sys.argv[2] - if engine not in ["servo-2013", "servo-2020", "gecko"] or output not in [ + if engine not in ["servo", "gecko"] or output not in [ "style-crate", "geckolib", - "html", ]: abort(usage) properties = data.PropertiesData(engine=engine) - files = {} - for kind in ["longhands", "shorthands"]: - files[kind] = {} - for struct in STYLE_STRUCT_LIST: - file_name = os.path.join(BASE, kind, "{}.mako.rs".format(struct)) - if kind == "shorthands" and not os.path.exists(file_name): - files[kind][struct] = "" - continue - files[kind][struct] = render( - file_name, - engine=engine, - data=properties, - ) properties_template = os.path.join(BASE, "properties.mako.rs") - files["properties"] = render( + properties_file = render( properties_template, engine=engine, data=properties, @@ -87,31 +47,15 @@ def main(): OUT_DIR=OUT_DIR, ) if output == "style-crate": - write(OUT_DIR, "properties.rs", files["properties"]) - for kind in ["longhands", "shorthands"]: - for struct in files[kind]: - write( - os.path.join(OUT_DIR, kind), - "{}.rs".format(struct), - files[kind][struct], - ) - - if engine == "gecko": - template = os.path.join(BASE, "gecko.mako.rs") - rust = render(template, data=properties) - write(OUT_DIR, "gecko_properties.rs", rust) - - if engine in ["servo-2013", "servo-2020"]: - if engine == "servo-2013": - pref_attr = "servo_2013_pref" - if engine == "servo-2020": - pref_attr = "servo_2020_pref" + write(OUT_DIR, "properties.rs", properties_file) + + if engine == "servo": properties_dict = { kind: { - p.name: {"pref": getattr(p, pref_attr)} + p.name: {"pref": getattr(p, "servo_pref")} for prop in properties_list if prop.enabled_in_content() - for p in [prop] + prop.alias + for p in [prop] + prop.aliases } for kind, properties_list in [ ("longhands", properties.longhands), diff --git a/servo/components/style/properties/cascade.rs b/servo/components/style/properties/cascade.rs index d4d48eaeb8..0f264a9249 100644 --- a/servo/components/style/properties/cascade.rs +++ b/servo/components/style/properties/cascade.rs @@ -297,7 +297,7 @@ where context.style().add_flags(cascade_input_flags); let using_cached_reset_properties; - let ignore_colors = !context.builder.device.use_document_colors(); + let ignore_colors = context.builder.device.forced_colors().is_active(); let mut cascade = Cascade::new(first_line_reparenting, ignore_colors); let mut declarations = Default::default(); let mut shorthand_cache = ShorthandsWithPropertyReferencesCache::default(); @@ -763,6 +763,11 @@ impl<'b> Cascade<'b> { if apply!(Zoom) { self.compute_zoom(context); + // NOTE(emilio): This is a bit of a hack, but matches the shipped WebKit and Blink + // behavior for now. Ideally, in the future, we have a pass over all + // implicitly-or-explicitly-inherited properties that can contain lengths and + // re-compute them properly, see https://github.com/w3c/csswg-drafts/issues/9397. + self.recompute_font_size_for_zoom_change(&mut context.builder); } // Compute font-family. @@ -1226,8 +1231,6 @@ impl<'b> Cascade<'b> { /// <svg:text> is not affected by text zoom, and it uses a preshint to disable it. We fix up /// the struct when this happens by unzooming its contained font values, which will have been /// zoomed in the parent. - /// - /// FIXME(emilio): Why doing this _before_ handling font-size? That sounds wrong. #[cfg(feature = "gecko")] fn unzoom_fonts_if_needed(&self, builder: &mut StyleBuilder) { debug_assert!(self.seen.contains(LonghandId::XTextScale)); @@ -1250,6 +1253,19 @@ impl<'b> Cascade<'b> { builder.mutate_font().unzoom_fonts(device); } + fn recompute_font_size_for_zoom_change(&self, builder: &mut StyleBuilder) { + debug_assert!(self.seen.contains(LonghandId::Zoom)); + // NOTE(emilio): Intentionally not using the effective zoom here, since all the inherited + // zooms are already applied. + let zoom = builder.get_box().clone_zoom(); + let old_size = builder.get_font().clone_font_size(); + let new_size = old_size.zoom(zoom); + if old_size == new_size { + return; + } + builder.mutate_font().set_font_size(new_size); + } + /// Special handling of font-size: math (used for MathML). /// https://w3c.github.io/mathml-core/#the-math-script-level-property /// TODO: Bug: 1548471: MathML Core also does not specify a script min size diff --git a/servo/components/style/properties/data.py b/servo/components/style/properties/data.py index 093f1cb75f..2a29a7ed58 100644 --- a/servo/components/style/properties/data.py +++ b/servo/components/style/properties/data.py @@ -176,11 +176,9 @@ class Keyword(object): gecko_enum_prefix=None, custom_consts=None, extra_gecko_values=None, - extra_servo_2013_values=None, - extra_servo_2020_values=None, + extra_servo_values=None, gecko_aliases=None, - servo_2013_aliases=None, - servo_2020_aliases=None, + servo_aliases=None, gecko_strip_moz_prefix=None, gecko_inexhaustive=None, ): @@ -196,11 +194,9 @@ class Keyword(object): ) self.gecko_enum_prefix = gecko_enum_prefix self.extra_gecko_values = (extra_gecko_values or "").split() - self.extra_servo_2013_values = (extra_servo_2013_values or "").split() - self.extra_servo_2020_values = (extra_servo_2020_values or "").split() + self.extra_servo_values = (extra_servo_values or "").split() self.gecko_aliases = parse_aliases(gecko_aliases or "") - self.servo_2013_aliases = parse_aliases(servo_2013_aliases or "") - self.servo_2020_aliases = parse_aliases(servo_2020_aliases or "") + self.servo_aliases = parse_aliases(servo_aliases or "") self.consts_map = {} if custom_consts is None else custom_consts self.gecko_strip_moz_prefix = ( True if gecko_strip_moz_prefix is None else gecko_strip_moz_prefix @@ -210,20 +206,16 @@ class Keyword(object): def values_for(self, engine): if engine == "gecko": return self.values + self.extra_gecko_values - elif engine == "servo-2013": - return self.values + self.extra_servo_2013_values - elif engine == "servo-2020": - return self.values + self.extra_servo_2020_values + elif engine == "servo": + return self.values + self.extra_servo_values else: raise Exception("Bad engine: " + engine) def aliases_for(self, engine): if engine == "gecko": return self.gecko_aliases - elif engine == "servo-2013": - return self.servo_2013_aliases - elif engine == "servo-2020": - return self.servo_2020_aliases + elif engine == "servo": + return self.servo_aliases else: raise Exception("Bad engine: " + engine) @@ -289,8 +281,7 @@ class Property(object): self, name, spec, - servo_2013_pref, - servo_2020_pref, + servo_pref, gecko_pref, enabled_in, rule_types_allowed, @@ -304,8 +295,7 @@ class Property(object): self.spec = spec self.ident = to_rust_ident(name) self.camel_case = to_camel_case(self.ident) - self.servo_2013_pref = servo_2013_pref - self.servo_2020_pref = servo_2020_pref + self.servo_pref = servo_pref self.gecko_pref = gecko_pref self.rule_types_allowed = rule_values_from_arg(rule_types_allowed) # For enabled_in, the setup is as follows: @@ -329,10 +319,8 @@ class Property(object): def experimental(self, engine): if engine == "gecko": return bool(self.gecko_pref) - elif engine == "servo-2013": - return bool(self.servo_2013_pref) - elif engine == "servo-2020": - return bool(self.servo_2020_pref) + elif engine == "servo": + return bool(self.servo_pref) else: raise Exception("Bad engine: " + engine) @@ -364,8 +352,7 @@ class Longhand(Property): animation_value_type=None, keyword=None, predefined_type=None, - servo_2013_pref=None, - servo_2020_pref=None, + servo_pref=None, gecko_pref=None, enabled_in="content", need_index=False, @@ -390,8 +377,7 @@ class Longhand(Property): self, name=name, spec=spec, - servo_2013_pref=servo_2013_pref, - servo_2020_pref=servo_2020_pref, + servo_pref=servo_pref, gecko_pref=gecko_pref, enabled_in=enabled_in, rule_types_allowed=rule_types_allowed, @@ -518,16 +504,8 @@ class Longhand(Property): def may_be_disabled_in(self, shorthand, engine): if engine == "gecko": return self.gecko_pref and self.gecko_pref != shorthand.gecko_pref - elif engine == "servo-2013": - return ( - self.servo_2013_pref - and self.servo_2013_pref != shorthand.servo_2013_pref - ) - elif engine == "servo-2020": - return ( - self.servo_2020_pref - and self.servo_2020_pref != shorthand.servo_2020_pref - ) + elif engine == "servo": + return self.servo_pref and self.servo_pref != shorthand.servo_pref else: raise Exception("Bad engine: " + engine) @@ -659,8 +637,7 @@ class Shorthand(Property): name, sub_properties, spec=None, - servo_2013_pref=None, - servo_2020_pref=None, + servo_pref=None, gecko_pref=None, enabled_in="content", rule_types_allowed=DEFAULT_RULES, @@ -672,8 +649,7 @@ class Shorthand(Property): self, name=name, spec=spec, - servo_2013_pref=servo_2013_pref, - servo_2020_pref=servo_2020_pref, + servo_pref=servo_pref, gecko_pref=gecko_pref, enabled_in=enabled_in, rule_types_allowed=rule_types_allowed, @@ -704,8 +680,7 @@ class Alias(object): self.original = original self.enabled_in = original.enabled_in self.animatable = original.animatable - self.servo_2013_pref = original.servo_2013_pref - self.servo_2020_pref = original.servo_2020_pref + self.servo_pref = original.servo_pref self.gecko_pref = gecko_pref self.rule_types_allowed = original.rule_types_allowed self.flags = original.flags @@ -722,10 +697,8 @@ class Alias(object): def experimental(self, engine): if engine == "gecko": return bool(self.gecko_pref) - elif engine == "servo-2013": - return bool(self.servo_2013_pref) - elif engine == "servo-2020": - return bool(self.servo_2020_pref) + elif engine == "servo": + return bool(self.servo_pref) else: raise Exception("Bad engine: " + engine) @@ -768,7 +741,7 @@ class Method(object): class StyleStruct(object): - def __init__(self, name, inherited, gecko_name=None, additional_methods=None): + def __init__(self, name, inherited, gecko_name=None): self.gecko_struct_name = "Gecko" + name self.name = name self.name_lower = to_snake_case(name) @@ -777,15 +750,12 @@ class StyleStruct(object): self.inherited = inherited self.gecko_name = gecko_name or name self.gecko_ffi_name = "nsStyle" + self.gecko_name - self.additional_methods = additional_methods or [] self.document_dependent = self.gecko_name in ["Font", "Visibility", "Text"] class PropertiesData(object): def __init__(self, engine): self.engine = engine - self.style_structs = [] - self.current_style_struct = None self.longhands = [] self.longhands_by_name = {} self.longhands_by_logical_group = {} @@ -797,13 +767,35 @@ class PropertiesData(object): CountedUnknownProperty(p) for p in COUNTED_UNKNOWN_PROPERTIES ] - def new_style_struct(self, *args, **kwargs): - style_struct = StyleStruct(*args, **kwargs) - self.style_structs.append(style_struct) - self.current_style_struct = style_struct + self.style_structs = [ + StyleStruct("Background", inherited=False), + StyleStruct("Border", inherited=False), + StyleStruct("Box", inherited=False, gecko_name="Display"), + StyleStruct("Column", inherited=False), + StyleStruct("Counters", inherited=False, gecko_name="Content"), + StyleStruct("Effects", inherited=False), + StyleStruct("Font", inherited=True), + StyleStruct("InheritedBox", inherited=True, gecko_name="Visibility"), + StyleStruct("InheritedSVG", inherited=True, gecko_name="SVG"), + StyleStruct("InheritedTable", inherited=True, gecko_name="TableBorder"), + StyleStruct("InheritedText", inherited=True, gecko_name="Text"), + StyleStruct("InheritedUI", inherited=True, gecko_name="UI"), + StyleStruct("List", inherited=True), + StyleStruct("Margin", inherited=False), + StyleStruct("Outline", inherited=False), + StyleStruct("Padding", inherited=False), + StyleStruct("Page", inherited=False), + StyleStruct("Position", inherited=False), + StyleStruct("SVG", inherited=False, gecko_name="SVGReset"), + StyleStruct("Table", inherited=False), + StyleStruct("Text", inherited=False, gecko_name="TextReset"), + StyleStruct("UI", inherited=False, gecko_name="UIReset"), + StyleStruct("XUL", inherited=False), + ] + self.current_style_struct = None def active_style_structs(self): - return [s for s in self.style_structs if s.additional_methods or s.longhands] + return [s for s in self.style_structs if s.longhands] def add_prefixed_aliases(self, property): # FIXME Servo's DOM architecture doesn't support vendor-prefixed properties. @@ -856,7 +848,7 @@ def _add_logical_props(data, props): groups = set() for prop in props: if prop not in data.longhands_by_name: - assert data.engine in ["servo-2013", "servo-2020"] + assert data.engine == "servo" continue prop = data.longhands_by_name[prop] if prop.logical_group: diff --git a/servo/components/style/properties/declaration_block.rs b/servo/components/style/properties/declaration_block.rs index 81d7148e62..94945ab8c0 100644 --- a/servo/components/style/properties/declaration_block.rs +++ b/servo/components/style/properties/declaration_block.rs @@ -36,10 +36,10 @@ use cssparser::{ use itertools::Itertools; use selectors::SelectorList; use servo_arc::Arc; -use smallbitvec::{self, SmallBitVec}; +use smallbitvec::SmallBitVec; use smallvec::SmallVec; use std::fmt::{self, Write}; -use std::iter::{DoubleEndedIterator, Zip}; +use std::iter::Zip; use std::slice::Iter; use style_traits::{CssWriter, ParseError, ParsingMode, StyleParseErrorKind, ToCss}; use thin_vec::ThinVec; diff --git a/servo/components/style/properties/helpers.mako.rs b/servo/components/style/properties/helpers.mako.rs index 968a97aa00..82998632ca 100644 --- a/servo/components/style/properties/helpers.mako.rs +++ b/servo/components/style/properties/helpers.mako.rs @@ -594,11 +594,9 @@ 'gecko_constant_prefix', 'gecko_enum_prefix', 'extra_gecko_values', - 'extra_servo_2013_values', - 'extra_servo_2020_values', + 'extra_servo_values', 'gecko_aliases', - 'servo_2013_aliases', - 'servo_2020_aliases', + 'servo_aliases', 'custom_consts', 'gecko_inexhaustive', 'gecko_strip_moz_prefix', diff --git a/servo/components/style/properties/helpers/animated_properties.mako.rs b/servo/components/style/properties/helpers/animated_properties.mako.rs index 290684cdab..171413b243 100644 --- a/servo/components/style/properties/helpers/animated_properties.mako.rs +++ b/servo/components/style/properties/helpers/animated_properties.mako.rs @@ -737,7 +737,7 @@ impl<'a> TransitionPropertyIterator<'a> { /// A single iteration of the TransitionPropertyIterator. pub struct TransitionPropertyIteration { /// The id of the longhand for this property. - pub longhand_id: LonghandId, + pub property: OwnedPropertyDeclarationId, /// The index of this property in the list of transition properties for this /// iterator's style. @@ -753,7 +753,7 @@ impl<'a> Iterator for TransitionPropertyIterator<'a> { if let Some(ref mut longhand_iterator) = self.longhand_iterator { if let Some(longhand_id) = longhand_iterator.next() { return Some(TransitionPropertyIteration { - longhand_id, + property: OwnedPropertyDeclarationId::Longhand(longhand_id), index: self.index_range.start - 1, }); } @@ -766,7 +766,7 @@ impl<'a> Iterator for TransitionPropertyIterator<'a> { match id.longhand_or_shorthand() { Ok(longhand_id) => { return Some(TransitionPropertyIteration { - longhand_id, + property: OwnedPropertyDeclarationId::Longhand(longhand_id), index, }); }, @@ -778,7 +778,13 @@ impl<'a> Iterator for TransitionPropertyIterator<'a> { }, } } - TransitionProperty::Custom(..) | TransitionProperty::Unsupported(..) => {} + TransitionProperty::Custom(name) => { + return Some(TransitionPropertyIteration { + property: OwnedPropertyDeclarationId::Custom(name), + index, + }) + }, + TransitionProperty::Unsupported(..) => {}, } } } diff --git a/servo/components/style/properties/longhands/background.mako.rs b/servo/components/style/properties/longhands/background.mako.rs index 48270f748e..535dd64e20 100644 --- a/servo/components/style/properties/longhands/background.mako.rs +++ b/servo/components/style/properties/longhands/background.mako.rs @@ -4,13 +4,11 @@ <%namespace name="helpers" file="/helpers.mako.rs" /> -<% data.new_style_struct("Background", inherited=False) %> - ${helpers.predefined_type( "background-color", "Color", "computed::Color::TRANSPARENT_BLACK", - engines="gecko servo-2013 servo-2020", + engines="gecko servo", initial_specified_value="SpecifiedValue::transparent()", spec="https://drafts.csswg.org/css-backgrounds/#background-color", animation_value_type="AnimatedColor", @@ -23,7 +21,7 @@ ${helpers.predefined_type( ${helpers.predefined_type( "background-image", "Image", - engines="gecko servo-2013 servo-2020", + engines="gecko servo", initial_value="computed::Image::None", initial_specified_value="specified::Image::None", spec="https://drafts.csswg.org/css-backgrounds/#the-background-image", @@ -38,7 +36,7 @@ ${helpers.predefined_type( "background-position-" + axis, "position::" + direction + "Position", "computed::LengthPercentage::zero_percent()", - engines="gecko servo-2013 servo-2020", + engines="gecko servo", initial_specified_value="SpecifiedValue::initial_specified_value()", spec="https://drafts.csswg.org/css-backgrounds-4/#propdef-background-position-" + axis, animation_value_type="ComputedValue", @@ -52,7 +50,7 @@ ${helpers.predefined_type( "background-repeat", "BackgroundRepeat", "computed::BackgroundRepeat::repeat()", - engines="gecko servo-2013 servo-2020", + engines="gecko servo", initial_specified_value="specified::BackgroundRepeat::repeat()", animation_value_type="discrete", vector=True, @@ -62,8 +60,8 @@ ${helpers.predefined_type( ${helpers.single_keyword( "background-attachment", - "scroll" + (" fixed" if engine in ["gecko", "servo-2013"] else "") + (" local" if engine == "gecko" else ""), - engines="gecko servo-2013 servo-2020", + "scroll fixed" + (" local" if engine == "gecko" else ""), + engines="gecko servo", vector=True, gecko_enum_prefix="StyleImageLayerAttachment", spec="https://drafts.csswg.org/css-backgrounds/#the-background-attachment", @@ -74,7 +72,7 @@ ${helpers.single_keyword( ${helpers.single_keyword( "background-clip", "border-box padding-box content-box", - engines="gecko servo-2013 servo-2020", + engines="gecko servo", extra_gecko_values="text", vector=True, extra_prefixes="webkit", gecko_enum_prefix="StyleGeometryBox", @@ -87,7 +85,7 @@ ${helpers.single_keyword( ${helpers.single_keyword( "background-origin", "padding-box border-box content-box", - engines="gecko servo-2013 servo-2020", + engines="gecko servo", vector=True, extra_prefixes="webkit", gecko_enum_prefix="StyleGeometryBox", gecko_inexhaustive=True, @@ -99,7 +97,7 @@ ${helpers.single_keyword( ${helpers.predefined_type( "background-size", "BackgroundSize", - engines="gecko servo-2013 servo-2020", + engines="gecko servo", initial_value="computed::BackgroundSize::auto()", initial_specified_value="specified::BackgroundSize::auto()", spec="https://drafts.csswg.org/css-backgrounds/#the-background-size", diff --git a/servo/components/style/properties/longhands/border.mako.rs b/servo/components/style/properties/longhands/border.mako.rs index 4d0676f678..59a0fee94a 100644 --- a/servo/components/style/properties/longhands/border.mako.rs +++ b/servo/components/style/properties/longhands/border.mako.rs @@ -3,11 +3,8 @@ * file, You can obtain one at https://mozilla.org/MPL/2.0/. */ <%namespace name="helpers" file="/helpers.mako.rs" /> -<% from data import Keyword, Method, ALL_CORNERS, PHYSICAL_SIDES, ALL_SIDES, maybe_moz_logical_alias %> +<% from data import ALL_CORNERS, ALL_SIDES, maybe_moz_logical_alias %> -<% data.new_style_struct("Border", inherited=False, - additional_methods=[Method("border_" + side + "_has_nonzero_width", - "bool") for side in ["top", "right", "bottom", "left"]]) %> <% def maybe_logical_spec(side, kind): if side[1]: # if it is logical @@ -23,7 +20,7 @@ ${helpers.predefined_type( "border-%s-color" % side_name, "Color", "computed_value::T::currentcolor()", - engines="gecko servo-2013 servo-2020", + engines="gecko servo", aliases=maybe_moz_logical_alias(engine, side, "-moz-border-%s-color"), spec=maybe_logical_spec(side, "color"), animation_value_type="AnimatedColor", @@ -37,7 +34,7 @@ ${helpers.predefined_type( "border-%s-style" % side_name, "BorderStyle", "specified::BorderStyle::None", - engines="gecko servo-2013 servo-2020", + engines="gecko servo", aliases=maybe_moz_logical_alias(engine, side, "-moz-border-%s-style"), spec=maybe_logical_spec(side, "style"), animation_value_type="discrete" if not is_logical else "none", @@ -50,7 +47,7 @@ "border-%s-width" % side_name, "BorderSideWidth", "app_units::Au::from_px(3)", - engines="gecko servo-2013 servo-2020", + engines="gecko servo", aliases=maybe_moz_logical_alias(engine, side, "-moz-border-%s-width"), spec=maybe_logical_spec(side, "width"), animation_value_type="NonNegativeLength", @@ -76,7 +73,7 @@ "BorderCornerRadius", "computed::BorderCornerRadius::zero()", "parse", - engines="gecko servo-2013 servo-2020", + engines="gecko servo", extra_prefixes=prefixes, spec=maybe_logical_spec(corner, "radius"), boxed=True, @@ -111,13 +108,13 @@ ${helpers.single_keyword( ${helpers.predefined_type( "border-image-source", "Image", - engines="gecko servo-2013 servo-2020", + engines="gecko servo", initial_value="computed::Image::None", initial_specified_value="specified::Image::None", spec="https://drafts.csswg.org/css-backgrounds/#the-background-image", vector=False, animation_value_type="discrete", - boxed=engine == "servo-2013", + boxed=engine == "servo", ignored_when_colors_disabled=True, affects="paint", )} @@ -125,7 +122,7 @@ ${helpers.predefined_type( ${helpers.predefined_type( "border-image-outset", "NonNegativeLengthOrNumberRect", - engines="gecko servo-2013 servo-2020", + engines="gecko servo", initial_value="generics::rect::Rect::all(computed::NonNegativeLengthOrNumber::zero())", initial_specified_value="generics::rect::Rect::all(specified::NonNegativeLengthOrNumber::zero())", spec="https://drafts.csswg.org/css-backgrounds/#border-image-outset", @@ -138,7 +135,7 @@ ${helpers.predefined_type( "border-image-repeat", "BorderImageRepeat", "computed::BorderImageRepeat::stretch()", - engines="gecko servo-2013 servo-2020", + engines="gecko servo", initial_specified_value="specified::BorderImageRepeat::stretch()", animation_value_type="discrete", spec="https://drafts.csswg.org/css-backgrounds/#the-border-image-repeat", @@ -148,7 +145,7 @@ ${helpers.predefined_type( ${helpers.predefined_type( "border-image-width", "BorderImageWidth", - engines="gecko servo-2013 servo-2020", + engines="gecko servo", initial_value="computed::BorderImageWidth::all(computed::BorderImageSideWidth::one())", initial_specified_value="specified::BorderImageWidth::all(specified::BorderImageSideWidth::one())", spec="https://drafts.csswg.org/css-backgrounds/#border-image-width", @@ -160,7 +157,7 @@ ${helpers.predefined_type( ${helpers.predefined_type( "border-image-slice", "BorderImageSlice", - engines="gecko servo-2013 servo-2020", + engines="gecko servo", initial_value="computed::BorderImageSlice::hundred_percent()", initial_specified_value="specified::BorderImageSlice::hundred_percent()", spec="https://drafts.csswg.org/css-backgrounds/#border-image-slice", diff --git a/servo/components/style/properties/longhands/box.mako.rs b/servo/components/style/properties/longhands/box.mako.rs index 017bef38ea..187e8f8169 100644 --- a/servo/components/style/properties/longhands/box.mako.rs +++ b/servo/components/style/properties/longhands/box.mako.rs @@ -3,17 +3,13 @@ * file, You can obtain one at https://mozilla.org/MPL/2.0/. */ <%namespace name="helpers" file="/helpers.mako.rs" /> -<% from data import ALL_AXES, Keyword, Method, to_rust_ident, to_camel_case%> - -<% data.new_style_struct("Box", - inherited=False, - gecko_name="Display") %> +<% from data import ALL_AXES %> ${helpers.predefined_type( "display", "Display", "computed::Display::inline()", - engines="gecko servo-2013 servo-2020", + engines="gecko servo", initial_specified_value="specified::Display::inline()", animation_value_type="discrete", spec="https://drafts.csswg.org/css-display/#propdef-display", @@ -38,7 +34,7 @@ ${helpers.single_keyword( ${helpers.single_keyword( "-servo-top-layer", "none top", - engines="servo-2013 servo-2020", + engines="servo", animation_value_type="none", enabled_in="ua", spec="Internal (not web-exposed)", @@ -47,8 +43,8 @@ ${helpers.single_keyword( <%helpers:single_keyword name="position" - values="static absolute relative fixed ${'sticky' if engine in ['gecko', 'servo-2013'] else ''}" - engines="gecko servo-2013 servo-2020" + values="static absolute relative fixed sticky" + engines="gecko servo" animation_value_type="discrete" gecko_enum_prefix="StylePositionProperty" spec="https://drafts.csswg.org/css-position/#position-property" @@ -69,8 +65,7 @@ ${helpers.predefined_type( "float", "Float", "computed::Float::None", - engines="gecko servo-2013 servo-2020", - servo_2020_pref="layout.2020.unimplemented", + engines="gecko servo", initial_specified_value="specified::Float::None", spec="https://drafts.csswg.org/css-box/#propdef-float", animation_value_type="discrete", @@ -83,7 +78,7 @@ ${helpers.predefined_type( "clear", "Clear", "computed::Clear::None", - engines="gecko servo-2013", + engines="gecko servo", animation_value_type="discrete", spec="https://drafts.csswg.org/css2/#propdef-clear", servo_restyle_damage="rebuild_and_reflow", @@ -94,7 +89,7 @@ ${helpers.predefined_type( "vertical-align", "VerticalAlign", "computed::VerticalAlign::baseline()", - engines="gecko servo-2013", + engines="gecko servo", animation_value_type="ComputedValue", spec="https://www.w3.org/TR/CSS2/visudet.html#propdef-vertical-align", servo_restyle_damage = "reflow", @@ -105,7 +100,7 @@ ${helpers.predefined_type( "baseline-source", "BaselineSource", "computed::BaselineSource::Auto", - engines="gecko servo-2013", + engines="gecko servo", animation_value_type="discrete", spec="https://drafts.csswg.org/css-inline-3/#baseline-source", servo_restyle_damage = "reflow", @@ -117,7 +112,8 @@ ${helpers.predefined_type( ${helpers.single_keyword( "-servo-overflow-clip-box", "padding-box content-box", - engines="servo-2013", + engines="servo", + servo_pref="layout.legacy_layout", animation_value_type="none", enabled_in="ua", spec="Internal, not web-exposed, \ @@ -146,7 +142,7 @@ ${helpers.single_keyword( full_name, "Overflow", "computed::Overflow::Visible", - engines="gecko servo-2013 servo-2020", + engines="gecko servo", logical_group="overflow", logical=logical, animation_value_type="discrete", @@ -174,7 +170,7 @@ ${helpers.predefined_type( "transform", "Transform", "generics::transform::Transform::none()", - engines="gecko servo-2013 servo-2020", + engines="gecko servo", extra_prefixes=transform_extra_prefixes, animation_value_type="ComputedValue", flags="CAN_ANIMATE_ON_COMPOSITOR", @@ -187,7 +183,7 @@ ${helpers.predefined_type( "rotate", "Rotate", "generics::transform::Rotate::None", - engines="gecko servo-2013", + engines="gecko servo", animation_value_type="ComputedValue", boxed=True, flags="CAN_ANIMATE_ON_COMPOSITOR", @@ -201,7 +197,7 @@ ${helpers.predefined_type( "scale", "Scale", "generics::transform::Scale::None", - engines="gecko servo-2013", + engines="gecko servo", animation_value_type="ComputedValue", boxed=True, flags="CAN_ANIMATE_ON_COMPOSITOR", @@ -215,7 +211,7 @@ ${helpers.predefined_type( "translate", "Translate", "generics::transform::Translate::None", - engines="gecko servo-2013", + engines="gecko servo", animation_value_type="ComputedValue", boxed=True, flags="CAN_ANIMATE_ON_COMPOSITOR", @@ -285,7 +281,6 @@ ${helpers.predefined_type( "computed::OffsetPosition::normal()", engines="gecko", animation_value_type="ComputedValue", - gecko_pref="layout.css.motion-path-offset-position.enabled", flags="CAN_ANIMATE_ON_COMPOSITOR", spec="https://drafts.fxtf.org/motion-1/#offset-position-property", servo_restyle_damage="reflow_out_of_flow", @@ -409,7 +404,7 @@ ${helpers.predefined_type( "perspective", "Perspective", "computed::Perspective::none()", - engines="gecko servo-2013 servo-2020", + engines="gecko servo", gecko_ffi_name="mChildPerspective", spec="https://drafts.csswg.org/css-transforms/#perspective", extra_prefixes=transform_extra_prefixes, @@ -422,7 +417,7 @@ ${helpers.predefined_type( "perspective-origin", "Position", "computed::position::Position::center()", - engines="gecko servo-2013 servo-2020", + engines="gecko servo", boxed=True, extra_prefixes=transform_extra_prefixes, spec="https://drafts.csswg.org/css-transforms-2/#perspective-origin-property", @@ -434,7 +429,7 @@ ${helpers.predefined_type( ${helpers.single_keyword( "backface-visibility", "visible hidden", - engines="gecko servo-2013 servo-2020", + engines="gecko servo", gecko_enum_prefix="StyleBackfaceVisibility", spec="https://drafts.csswg.org/css-transforms/#backface-visibility-property", extra_prefixes=transform_extra_prefixes, @@ -456,7 +451,7 @@ ${helpers.predefined_type( "transform-style", "TransformStyle", "computed::TransformStyle::Flat", - engines="gecko servo-2013 servo-2020", + engines="gecko servo", spec="https://drafts.csswg.org/css-transforms-2/#transform-style-property", extra_prefixes=transform_extra_prefixes, animation_value_type="discrete", @@ -468,7 +463,7 @@ ${helpers.predefined_type( "transform-origin", "TransformOrigin", "computed::TransformOrigin::initial_value()", - engines="gecko servo-2013 servo-2020", + engines="gecko servo", animation_value_type="ComputedValue", extra_prefixes=transform_extra_prefixes, gecko_ffi_name="mTransformOrigin", @@ -503,10 +498,11 @@ ${helpers.predefined_type( "container-type", "ContainerType", "computed::ContainerType::Normal", - engines="gecko", + engines="gecko servo", animation_value_type="none", enabled_in="ua", gecko_pref="layout.css.container-queries.enabled", + servo_pref="layout.container-queries.enabled", spec="https://drafts.csswg.org/css-contain-3/#container-type", affects="layout", )} @@ -515,10 +511,11 @@ ${helpers.predefined_type( "container-name", "ContainerName", "computed::ContainerName::none()", - engines="gecko", + engines="gecko servo", animation_value_type="none", enabled_in="ua", gecko_pref="layout.css.container-queries.enabled", + servo_pref="layout.container-queries.enabled", spec="https://drafts.csswg.org/css-contain-3/#container-name", affects="", )} diff --git a/servo/components/style/properties/longhands/column.mako.rs b/servo/components/style/properties/longhands/column.mako.rs index 38c32938c6..ca97f36dba 100644 --- a/servo/components/style/properties/longhands/column.mako.rs +++ b/servo/components/style/properties/longhands/column.mako.rs @@ -4,17 +4,14 @@ <%namespace name="helpers" file="/helpers.mako.rs" /> -<% data.new_style_struct("Column", inherited=False) %> - ${helpers.predefined_type( "column-width", "length::NonNegativeLengthOrAuto", "computed::length::NonNegativeLengthOrAuto::auto()", - engines="gecko servo-2013 servo-2020", - servo_2020_pref="layout.2020.unimplemented", + engines="gecko servo", initial_specified_value="specified::length::NonNegativeLengthOrAuto::auto()", animation_value_type="NonNegativeLengthOrAuto", - servo_2013_pref="layout.columns.enabled", + servo_pref="layout.columns.enabled", spec="https://drafts.csswg.org/css-multicol/#propdef-column-width", servo_restyle_damage="rebuild_and_reflow", affects="layout", @@ -24,10 +21,9 @@ ${helpers.predefined_type( "column-count", "ColumnCount", "computed::ColumnCount::auto()", - engines="gecko servo-2013 servo-2020", - servo_2020_pref="layout.2020.unimplemented", + engines="gecko servo", initial_specified_value="specified::ColumnCount::auto()", - servo_2013_pref="layout.columns.enabled", + servo_pref="layout.columns.enabled", animation_value_type="AnimatedColumnCount", spec="https://drafts.csswg.org/css-multicol/#propdef-column-count", servo_restyle_damage="rebuild_and_reflow", @@ -71,7 +67,8 @@ ${helpers.predefined_type( ${helpers.single_keyword( "column-span", "none all", - engines="gecko", + engines="gecko servo", + servo_pref="layout.columns.enabled", animation_value_type="discrete", gecko_enum_prefix="StyleColumnSpan", spec="https://drafts.csswg.org/css-multicol/#propdef-column-span", diff --git a/servo/components/style/properties/longhands/counters.mako.rs b/servo/components/style/properties/longhands/counters.mako.rs index 6c844c3567..5991bd416c 100644 --- a/servo/components/style/properties/longhands/counters.mako.rs +++ b/servo/components/style/properties/longhands/counters.mako.rs @@ -4,13 +4,11 @@ <%namespace name="helpers" file="/helpers.mako.rs" /> -<% data.new_style_struct("Counters", inherited=False, gecko_name="Content") %> - ${helpers.predefined_type( "content", "Content", "computed::Content::normal()", - engines="gecko servo-2013 servo-2020", + engines="gecko servo", initial_specified_value="specified::Content::normal()", animation_value_type="discrete", spec="https://drafts.csswg.org/css-content/#propdef-content", @@ -21,7 +19,8 @@ ${helpers.predefined_type( ${helpers.predefined_type( "counter-increment", "CounterIncrement", - engines="gecko servo-2013", + engines="gecko servo", + servo_pref="layout.legacy_layout", initial_value="Default::default()", animation_value_type="discrete", spec="https://drafts.csswg.org/css-lists/#propdef-counter-increment", @@ -32,7 +31,8 @@ ${helpers.predefined_type( ${helpers.predefined_type( "counter-reset", "CounterReset", - engines="gecko servo-2013", + engines="gecko servo", + servo_pref="layout.legacy_layout", initial_value="Default::default()", animation_value_type="discrete", spec="https://drafts.csswg.org/css-lists-3/#propdef-counter-reset", diff --git a/servo/components/style/properties/longhands/effects.mako.rs b/servo/components/style/properties/longhands/effects.mako.rs index b301aab5dd..742844a670 100644 --- a/servo/components/style/properties/longhands/effects.mako.rs +++ b/servo/components/style/properties/longhands/effects.mako.rs @@ -4,14 +4,11 @@ <%namespace name="helpers" file="/helpers.mako.rs" /> -// Box-shadow, etc. -<% data.new_style_struct("Effects", inherited=False) %> - ${helpers.predefined_type( "opacity", "Opacity", "1.0", - engines="gecko servo-2013 servo-2020", + engines="gecko servo", animation_value_type="ComputedValue", flags="CAN_ANIMATE_ON_COMPOSITOR", spec="https://drafts.csswg.org/css-color/#transparency", @@ -23,8 +20,8 @@ ${helpers.predefined_type( "box-shadow", "BoxShadow", None, - engines="gecko servo-2013 servo-2020", - servo_2020_pref="layout.2020.unimplemented", + engines="gecko servo", + servo_pref="layout.legacy_layout", vector=True, simple_vector_bindings=True, animation_value_type="AnimatedBoxShadowList", @@ -39,7 +36,7 @@ ${helpers.predefined_type( "clip", "ClipRectOrAuto", "computed::ClipRectOrAuto::auto()", - engines="gecko servo-2013 servo-2020", + engines="gecko servo", animation_value_type="ComputedValue", boxed=True, allow_quirks="Yes", @@ -51,7 +48,7 @@ ${helpers.predefined_type( "filter", "Filter", None, - engines="gecko servo-2013 servo-2020", + engines="gecko servo", vector=True, simple_vector_bindings=True, gecko_ffi_name="mFilters", @@ -84,7 +81,7 @@ ${helpers.single_keyword( """normal multiply screen overlay darken lighten color-dodge color-burn hard-light soft-light difference exclusion hue saturation color luminosity plus-lighter""", - engines="gecko servo-2013 servo-2020", + engines="gecko servo", gecko_enum_prefix="StyleBlend", animation_value_type="discrete", spec="https://drafts.fxtf.org/compositing/#propdef-mix-blend-mode", diff --git a/servo/components/style/properties/longhands/font.mako.rs b/servo/components/style/properties/longhands/font.mako.rs index 4583de0bd7..3f7a2f0657 100644 --- a/servo/components/style/properties/longhands/font.mako.rs +++ b/servo/components/style/properties/longhands/font.mako.rs @@ -3,14 +3,12 @@ * file, You can obtain one at https://mozilla.org/MPL/2.0/. */ <%namespace name="helpers" file="/helpers.mako.rs" /> -<% from data import Method, to_camel_case, to_rust_ident, to_camel_case_lower, SYSTEM_FONT_LONGHANDS %> - -<% data.new_style_struct("Font", inherited=True) %> +<% from data import SYSTEM_FONT_LONGHANDS %> ${helpers.predefined_type( "font-family", "FontFamily", - engines="gecko servo-2013 servo-2020", + engines="gecko servo", initial_value="computed::FontFamily::serif()", animation_value_type="discrete", spec="https://drafts.csswg.org/css-fonts/#propdef-font-family", @@ -21,7 +19,7 @@ ${helpers.predefined_type( ${helpers.predefined_type( "font-style", "FontStyle", - engines="gecko servo-2013 servo-2020", + engines="gecko servo", initial_value="computed::FontStyle::normal()", initial_specified_value="specified::FontStyle::normal()", animation_value_type="FontStyle", @@ -39,7 +37,7 @@ ${helpers.predefined_type( ${helpers.single_keyword( "font-variant-caps", "normal small-caps", - engines="gecko servo-2013 servo-2020", + engines="gecko servo", extra_gecko_values="all-small-caps petite-caps all-petite-caps unicase titling-caps", gecko_constant_prefix="NS_FONT_VARIANT_CAPS", gecko_ffi_name="mFont.variantCaps", @@ -53,7 +51,7 @@ ${helpers.single_keyword( ${helpers.predefined_type( "font-weight", "FontWeight", - engines="gecko servo-2013 servo-2020", + engines="gecko servo", initial_value="computed::FontWeight::normal()", initial_specified_value="specified::FontWeight::normal()", animation_value_type="Number", @@ -65,7 +63,7 @@ ${helpers.predefined_type( ${helpers.predefined_type( "font-size", "FontSize", - engines="gecko servo-2013 servo-2020", + engines="gecko servo", initial_value="computed::FontSize::medium()", initial_specified_value="specified::FontSize::medium()", animation_value_type="NonNegativeLength", @@ -137,7 +135,7 @@ ${helpers.predefined_type( ${helpers.predefined_type( "font-stretch", "FontStretch", - engines="gecko servo-2013 servo-2020", + engines="gecko servo", initial_value="computed::FontStretch::hundred()", initial_specified_value="specified::FontStretch::normal()", animation_value_type="Percentage", @@ -354,7 +352,7 @@ ${helpers.predefined_type( "line-height", "LineHeight", "computed::LineHeight::normal()", - engines="gecko servo-2013 servo-2020", + engines="gecko servo", animation_value_type="LineHeight", spec="https://drafts.csswg.org/css2/visudet.html#propdef-line-height", servo_restyle_damage="reflow", diff --git a/servo/components/style/properties/longhands/inherited_box.mako.rs b/servo/components/style/properties/longhands/inherited_box.mako.rs index 7fd94d1a1f..add367798b 100644 --- a/servo/components/style/properties/longhands/inherited_box.mako.rs +++ b/servo/components/style/properties/longhands/inherited_box.mako.rs @@ -4,13 +4,11 @@ <%namespace name="helpers" file="/helpers.mako.rs" /> -<% data.new_style_struct("InheritedBox", inherited=True, gecko_name="Visibility") %> - // TODO: collapse. Well, do tables first. ${helpers.single_keyword( "visibility", "visible hidden collapse", - engines="gecko servo-2013 servo-2020", + engines="gecko servo", gecko_ffi_name="mVisible", animation_value_type="ComputedValue", spec="https://drafts.csswg.org/css-box/#propdef-visibility", @@ -23,13 +21,12 @@ ${helpers.single_keyword( ${helpers.single_keyword( "writing-mode", "horizontal-tb vertical-rl vertical-lr", - engines="gecko servo-2013 servo-2020", + engines="gecko servo", extra_gecko_values="sideways-rl sideways-lr", gecko_aliases="lr=horizontal-tb lr-tb=horizontal-tb \ rl=horizontal-tb rl-tb=horizontal-tb \ tb=vertical-rl tb-rl=vertical-rl", - servo_2013_pref="layout.writing-mode.enabled", - servo_2020_pref="layout.writing-mode.enabled", + servo_pref="layout.writing-mode.enabled", animation_value_type="none", spec="https://drafts.csswg.org/css-writing-modes/#propdef-writing-mode", gecko_enum_prefix="StyleWritingModeProperty", @@ -40,8 +37,8 @@ ${helpers.single_keyword( ${helpers.single_keyword( "direction", "ltr rtl", - engines="gecko servo-2013 servo-2020", - servo_2020_pref="layout.2020.unimplemented", + engines="gecko servo", + servo_pref="layout.legacy_layout", animation_value_type="none", spec="https://drafts.csswg.org/css-writing-modes/#propdef-direction", gecko_enum_prefix="StyleDirection", @@ -88,7 +85,7 @@ ${helpers.predefined_type( "image-rendering", "ImageRendering", "computed::ImageRendering::Auto", - engines="gecko servo-2013 servo-2020", + engines="gecko servo", spec="https://drafts.csswg.org/css-images/#propdef-image-rendering", animation_value_type="discrete", affects="paint", diff --git a/servo/components/style/properties/longhands/inherited_svg.mako.rs b/servo/components/style/properties/longhands/inherited_svg.mako.rs index 90443f962a..d01d5a4a80 100644 --- a/servo/components/style/properties/longhands/inherited_svg.mako.rs +++ b/servo/components/style/properties/longhands/inherited_svg.mako.rs @@ -4,10 +4,6 @@ <%namespace name="helpers" file="/helpers.mako.rs" /> -// SVG 2 -// https://svgwg.org/svg2-draft/ -<% data.new_style_struct("InheritedSVG", inherited=True, gecko_name="SVG") %> - // Section 10 - Text ${helpers.single_keyword( diff --git a/servo/components/style/properties/longhands/inherited_table.mako.rs b/servo/components/style/properties/longhands/inherited_table.mako.rs index 7eb42a6eb2..c7ada525b8 100644 --- a/servo/components/style/properties/longhands/inherited_table.mako.rs +++ b/servo/components/style/properties/longhands/inherited_table.mako.rs @@ -4,12 +4,11 @@ <%namespace name="helpers" file="/helpers.mako.rs" /> -<% data.new_style_struct("InheritedTable", inherited=True, gecko_name="TableBorder") %> - ${helpers.single_keyword( "border-collapse", "separate collapse", - engines="gecko servo-2013", + engines="gecko servo", + servo_pref="layout.legacy_layout", gecko_enum_prefix="StyleBorderCollapse", animation_value_type="discrete", spec="https://drafts.csswg.org/css-tables/#propdef-border-collapse", @@ -20,7 +19,8 @@ ${helpers.single_keyword( ${helpers.single_keyword( "empty-cells", "show hide", - engines="gecko servo-2013", + engines="gecko servo", + servo_pref="layout.legacy_layout", gecko_enum_prefix="StyleEmptyCells", animation_value_type="discrete", spec="https://drafts.csswg.org/css-tables/#propdef-empty-cells", @@ -32,7 +32,8 @@ ${helpers.predefined_type( "caption-side", "table::CaptionSide", "computed::table::CaptionSide::Top", - engines="gecko servo-2013", + engines="gecko servo", + servo_pref="layout.legacy_layout", animation_value_type="discrete", spec="https://drafts.csswg.org/css-tables/#propdef-caption-side", servo_restyle_damage="rebuild_and_reflow", @@ -43,8 +44,7 @@ ${helpers.predefined_type( "border-spacing", "BorderSpacing", "computed::BorderSpacing::zero()", - engines="gecko servo-2013 servo-2020", - servo_2020_pref="layout.2020.unimplemented", + engines="gecko servo", animation_value_type="BorderSpacing", boxed=True, spec="https://drafts.csswg.org/css-tables/#propdef-border-spacing", diff --git a/servo/components/style/properties/longhands/inherited_text.mako.rs b/servo/components/style/properties/longhands/inherited_text.mako.rs index 544ba99bf7..c6ad907b23 100644 --- a/servo/components/style/properties/longhands/inherited_text.mako.rs +++ b/servo/components/style/properties/longhands/inherited_text.mako.rs @@ -3,14 +3,12 @@ * file, You can obtain one at https://mozilla.org/MPL/2.0/. */ <%namespace name="helpers" file="/helpers.mako.rs" /> -<% from data import Keyword %> -<% data.new_style_struct("InheritedText", inherited=True, gecko_name="Text") %> ${helpers.predefined_type( "color", "ColorPropertyValue", "crate::color::AbsoluteColor::BLACK", - engines="gecko servo-2013 servo-2020", + engines="gecko servo", animation_value_type="AbsoluteColor", ignored_when_colors_disabled="True", spec="https://drafts.csswg.org/css-color/#color", @@ -23,7 +21,8 @@ ${helpers.predefined_type( "text-transform", "TextTransform", "computed::TextTransform::none()", - engines="gecko servo-2013", + engines="gecko servo", + servo_pref="layout.legacy_layout", animation_value_type="discrete", spec="https://drafts.csswg.org/css-text/#propdef-text-transform", servo_restyle_damage="rebuild_and_reflow", @@ -58,8 +57,7 @@ ${helpers.predefined_type( "text-indent", "TextIndent", "computed::TextIndent::zero()", - engines="gecko servo-2013 servo-2020", - servo_2020_pref="layout.2020.unimplemented", + engines="gecko servo", animation_value_type="ComputedValue", spec="https://drafts.csswg.org/css-text/#propdef-text-indent", servo_restyle_damage = "reflow", @@ -72,8 +70,8 @@ ${helpers.predefined_type( "overflow-wrap", "OverflowWrap", "computed::OverflowWrap::Normal", - engines="gecko servo-2013 servo-2020", - servo_2020_pref="layout.2020.unimplemented", + engines="gecko servo", + servo_pref="layout.legacy_layout", animation_value_type="discrete", spec="https://drafts.csswg.org/css-text/#propdef-overflow-wrap", aliases="word-wrap", @@ -85,8 +83,8 @@ ${helpers.predefined_type( "word-break", "WordBreak", "computed::WordBreak::Normal", - engines="gecko servo-2013 servo-2020", - servo_2020_pref="layout.2020.unimplemented", + engines="gecko servo", + servo_pref="layout.legacy_layout", animation_value_type="discrete", spec="https://drafts.csswg.org/css-text/#propdef-word-break", servo_restyle_damage="rebuild_and_reflow", @@ -97,8 +95,7 @@ ${helpers.predefined_type( "text-justify", "TextJustify", "computed::TextJustify::Auto", - engines="gecko servo-2013 servo-2020", - servo_2020_pref="layout.2020.unimplemented", + engines="gecko servo", animation_value_type="discrete", spec="https://drafts.csswg.org/css-text/#propdef-text-justify", servo_restyle_damage="rebuild_and_reflow", @@ -109,7 +106,7 @@ ${helpers.predefined_type( "text-align-last", "TextAlignLast", "computed::text::TextAlignLast::Auto", - engines="gecko", + engines="gecko servo", animation_value_type="discrete", spec="https://drafts.csswg.org/css-text/#propdef-text-align-last", affects="layout", @@ -120,7 +117,7 @@ ${helpers.predefined_type( "text-align", "TextAlign", "computed::TextAlign::Start", - engines="gecko servo-2013 servo-2020", + engines="gecko servo", animation_value_type="discrete", spec="https://drafts.csswg.org/css-text/#propdef-text-align", servo_restyle_damage = "reflow", @@ -131,7 +128,7 @@ ${helpers.predefined_type( "letter-spacing", "LetterSpacing", "computed::LetterSpacing::normal()", - engines="gecko servo-2013 servo-2020", + engines="gecko servo", animation_value_type="ComputedValue", spec="https://drafts.csswg.org/css-text/#propdef-letter-spacing", servo_restyle_damage="rebuild_and_reflow", @@ -142,7 +139,7 @@ ${helpers.predefined_type( "word-spacing", "WordSpacing", "computed::WordSpacing::zero()", - engines="gecko servo-2013 servo-2020", + engines="gecko servo", animation_value_type="ComputedValue", spec="https://drafts.csswg.org/css-text/#propdef-word-spacing", servo_restyle_damage="rebuild_and_reflow", @@ -164,7 +161,8 @@ ${helpers.predefined_type( "text-shadow", "SimpleShadow", None, - engines="gecko servo-2013", + engines="gecko servo", + servo_pref="layout.legacy_layout", vector=True, vector_animation_type="with_zero", animation_value_type="AnimatedTextShadowList", @@ -304,7 +302,7 @@ ${helpers.single_keyword( ${helpers.single_keyword( "text-rendering", "auto optimizespeed optimizelegibility geometricprecision", - engines="gecko servo-2013 servo-2020", + engines="gecko servo", gecko_enum_prefix="StyleTextRendering", animation_value_type="discrete", spec="https://svgwg.org/svg2-draft/painting.html#TextRenderingProperty", diff --git a/servo/components/style/properties/longhands/inherited_ui.mako.rs b/servo/components/style/properties/longhands/inherited_ui.mako.rs index 6cdf721336..7ee1adc602 100644 --- a/servo/components/style/properties/longhands/inherited_ui.mako.rs +++ b/servo/components/style/properties/longhands/inherited_ui.mako.rs @@ -4,13 +4,11 @@ <%namespace name="helpers" file="/helpers.mako.rs" /> -<% data.new_style_struct("InheritedUI", inherited=True, gecko_name="UI") %> - ${helpers.predefined_type( "cursor", "Cursor", "computed::Cursor::auto()", - engines="gecko servo-2013 servo-2020", + engines="gecko servo", initial_specified_value="specified::Cursor::auto()", animation_value_type="discrete", spec="https://drafts.csswg.org/css-ui/#cursor", @@ -23,7 +21,7 @@ ${helpers.predefined_type( ${helpers.single_keyword( "pointer-events", "auto none", - engines="gecko servo-2013 servo-2020", + engines="gecko servo", animation_value_type="discrete", extra_gecko_values="visiblepainted visiblefill visiblestroke visible painted fill stroke all", spec="https://svgwg.org/svg2-draft/interact.html#PointerEventsProperty", diff --git a/servo/components/style/properties/longhands/list.mako.rs b/servo/components/style/properties/longhands/list.mako.rs index 619724bd32..0a3f8e36ec 100644 --- a/servo/components/style/properties/longhands/list.mako.rs +++ b/servo/components/style/properties/longhands/list.mako.rs @@ -4,13 +4,11 @@ <%namespace name="helpers" file="/helpers.mako.rs" /> -<% data.new_style_struct("List", inherited=True) %> - ${helpers.single_keyword( "list-style-position", "outside inside", - engines="gecko servo-2013 servo-2020", - servo_2020_pref="layout.2020.unimplemented", + engines="gecko servo", + servo_pref="layout.legacy_layout", gecko_enum_prefix="StyleListStylePosition", animation_value_type="discrete", spec="https://drafts.csswg.org/css-lists/#propdef-list-style-position", @@ -24,17 +22,16 @@ ${helpers.single_keyword( // upper-roman // // [1]: http://dev.w3.org/csswg/css-counter-styles/ -% if engine in ["servo-2013", "servo-2020"]: +% if engine == "servo": ${helpers.single_keyword( "list-style-type", - "disc none circle square disclosure-open disclosure-closed", - extra_servo_2013_values=""" + """disc none circle square disclosure-open disclosure-closed decimal lower-alpha upper-alpha arabic-indic bengali cambodian cjk-decimal devanagari gujarati gurmukhi kannada khmer lao malayalam mongolian myanmar oriya persian telugu thai tibetan cjk-earthly-branch cjk-heavenly-stem lower-greek hiragana hiragana-iroha katakana katakana-iroha """, - engines="servo-2013 servo-2020", + engines="servo", animation_value_type="discrete", spec="https://drafts.csswg.org/css-lists/#propdef-list-style-type", servo_restyle_damage="rebuild_and_reflow", @@ -59,11 +56,12 @@ ${helpers.single_keyword( ${helpers.predefined_type( "list-style-image", "Image", - engines="gecko servo-2013 servo-2020", + engines="gecko servo", initial_value="computed::Image::None", initial_specified_value="specified::Image::None", animation_value_type="discrete", spec="https://drafts.csswg.org/css-lists/#propdef-list-style-image", + boxed=engine == "servo", servo_restyle_damage="rebuild_and_reflow", affects="layout", )} @@ -72,7 +70,8 @@ ${helpers.predefined_type( "quotes", "Quotes", "computed::Quotes::get_initial_value()", - engines="gecko servo-2013", + engines="gecko servo", + servo_pref="layout.legacy_layout", animation_value_type="discrete", spec="https://drafts.csswg.org/css-content/#propdef-quotes", servo_restyle_damage="rebuild_and_reflow", diff --git a/servo/components/style/properties/longhands/margin.mako.rs b/servo/components/style/properties/longhands/margin.mako.rs index b5a87f9683..1000704140 100644 --- a/servo/components/style/properties/longhands/margin.mako.rs +++ b/servo/components/style/properties/longhands/margin.mako.rs @@ -4,7 +4,6 @@ <%namespace name="helpers" file="/helpers.mako.rs" /> <% from data import ALL_SIDES, DEFAULT_RULES_AND_PAGE, maybe_moz_logical_alias %> -<% data.new_style_struct("Margin", inherited=False) %> % for side in ALL_SIDES: <% @@ -16,7 +15,7 @@ "margin-%s" % side[0], "LengthPercentageOrAuto", "computed::LengthPercentageOrAuto::zero()", - engines="gecko servo-2013 servo-2020", + engines="gecko servo", aliases=maybe_moz_logical_alias(engine, side, "-moz-margin-%s"), allow_quirks="No" if side[1] else "Yes", animation_value_type="ComputedValue", diff --git a/servo/components/style/properties/longhands/outline.mako.rs b/servo/components/style/properties/longhands/outline.mako.rs index 8e7f956bf5..d366cbc996 100644 --- a/servo/components/style/properties/longhands/outline.mako.rs +++ b/servo/components/style/properties/longhands/outline.mako.rs @@ -3,18 +3,12 @@ * file, You can obtain one at https://mozilla.org/MPL/2.0/. */ <%namespace name="helpers" file="/helpers.mako.rs" /> -<% from data import Method %> -<% data.new_style_struct("Outline", - inherited=False, - additional_methods=[Method("outline_has_nonzero_width", "bool")]) %> - -// TODO(pcwalton): `invert` ${helpers.predefined_type( "outline-color", "Color", "computed_value::T::currentcolor()", - engines="gecko servo-2013", + engines="gecko servo", initial_specified_value="specified::Color::currentcolor()", animation_value_type="AnimatedColor", ignored_when_colors_disabled=True, @@ -26,8 +20,7 @@ ${helpers.predefined_type( "outline-style", "OutlineStyle", "computed::OutlineStyle::none()", - engines="gecko servo-2013 servo-2020", - servo_2020_pref="layout.2020.unimplemented", + engines="gecko servo", initial_specified_value="specified::OutlineStyle::none()", animation_value_type="discrete", spec="https://drafts.csswg.org/css-ui/#propdef-outline-style", @@ -38,8 +31,7 @@ ${helpers.predefined_type( "outline-width", "BorderSideWidth", "app_units::Au::from_px(3)", - engines="gecko servo-2013 servo-2020", - servo_2020_pref="layout.2020.unimplemented", + engines="gecko servo", initial_specified_value="specified::BorderSideWidth::medium()", animation_value_type="NonNegativeLength", spec="https://drafts.csswg.org/css-ui/#propdef-outline-width", @@ -50,7 +42,7 @@ ${helpers.predefined_type( "outline-offset", "Length", "crate::values::computed::Length::new(0.)", - engines="gecko servo-2013", + engines="gecko servo", animation_value_type="ComputedValue", spec="https://drafts.csswg.org/css-ui/#propdef-outline-offset", affects="overflow", diff --git a/servo/components/style/properties/longhands/padding.mako.rs b/servo/components/style/properties/longhands/padding.mako.rs index a165e2cd34..d3984b71d2 100644 --- a/servo/components/style/properties/longhands/padding.mako.rs +++ b/servo/components/style/properties/longhands/padding.mako.rs @@ -4,7 +4,6 @@ <%namespace name="helpers" file="/helpers.mako.rs" /> <% from data import ALL_SIDES, maybe_moz_logical_alias %> -<% data.new_style_struct("Padding", inherited=False) %> % for side in ALL_SIDES: <% @@ -16,7 +15,7 @@ "padding-%s" % side[0], "NonNegativeLengthPercentage", "computed::NonNegativeLengthPercentage::zero()", - engines="gecko servo-2013 servo-2020", + engines="gecko servo", aliases=maybe_moz_logical_alias(engine, side, "-moz-padding-%s"), animation_value_type="NonNegativeLengthPercentage", logical=side[1], diff --git a/servo/components/style/properties/longhands/page.mako.rs b/servo/components/style/properties/longhands/page.mako.rs index 86cd284e18..bb7729c722 100644 --- a/servo/components/style/properties/longhands/page.mako.rs +++ b/servo/components/style/properties/longhands/page.mako.rs @@ -5,8 +5,6 @@ <%namespace name="helpers" file="/helpers.mako.rs" /> <% from data import PAGE_RULE %> -<% data.new_style_struct("Page", inherited=False) %> - ${helpers.predefined_type( "size", "PageSize", diff --git a/servo/components/style/properties/longhands/position.mako.rs b/servo/components/style/properties/longhands/position.mako.rs index fb68baa6b4..e71803e026 100644 --- a/servo/components/style/properties/longhands/position.mako.rs +++ b/servo/components/style/properties/longhands/position.mako.rs @@ -2,19 +2,16 @@ * License, v. 2.0. If a copy of the MPL was not distributed with this * file, You can obtain one at https://mozilla.org/MPL/2.0/. */ -<%! from data import to_rust_ident %> <%namespace name="helpers" file="/helpers.mako.rs" /> <% from data import ALL_SIZES, PHYSICAL_SIDES, LOGICAL_SIDES %> -<% data.new_style_struct("Position", inherited=False) %> - // "top" / "left" / "bottom" / "right" % for side in PHYSICAL_SIDES: ${helpers.predefined_type( side, "LengthPercentageOrAuto", "computed::LengthPercentageOrAuto::auto()", - engines="gecko servo-2013 servo-2020", + engines="gecko servo", spec="https://www.w3.org/TR/CSS2/visuren.html#propdef-%s" % side, animation_value_type="ComputedValue", allow_quirks="Yes", @@ -29,7 +26,7 @@ "inset-%s" % side, "LengthPercentageOrAuto", "computed::LengthPercentageOrAuto::auto()", - engines="gecko servo-2013 servo-2020", + engines="gecko servo", spec="https://drafts.csswg.org/css-logical-props/#propdef-inset-%s" % side, animation_value_type="ComputedValue", logical=True, @@ -42,7 +39,7 @@ ${helpers.predefined_type( "z-index", "ZIndex", "computed::ZIndex::auto()", - engines="gecko servo-2013 servo-2020", + engines="gecko servo", spec="https://www.w3.org/TR/CSS2/visuren.html#z-index", animation_value_type="ComputedValue", affects="paint", @@ -55,8 +52,8 @@ ${helpers.predefined_type( ${helpers.single_keyword( "flex-direction", "row row-reverse column column-reverse", - engines="gecko servo-2013 servo-2020", - servo_2020_pref="layout.flexbox.enabled", + engines="gecko servo", + servo_pref="layout.flexbox.enabled", spec="https://drafts.csswg.org/css-flexbox/#flex-direction-property", extra_prefixes="webkit", animation_value_type="discrete", @@ -68,8 +65,8 @@ ${helpers.single_keyword( ${helpers.single_keyword( "flex-wrap", "nowrap wrap wrap-reverse", - engines="gecko servo-2013 servo-2020", - servo_2020_pref="layout.flexbox.enabled", + engines="gecko servo", + servo_pref="layout.flexbox.enabled", spec="https://drafts.csswg.org/css-flexbox/#flex-wrap-property", extra_prefixes="webkit", animation_value_type="discrete", @@ -78,12 +75,13 @@ ${helpers.single_keyword( affects="layout", )} -% if engine == "servo-2013": +% if engine in "servo": // FIXME: Update Servo to support the same Syntax as Gecko. ${helpers.single_keyword( "justify-content", "flex-start stretch flex-end center space-between space-around", - engines="servo-2013", + engines="servo", + servo_pref="layout.flexbox.enabled", extra_prefixes="webkit", spec="https://drafts.csswg.org/css-align/#propdef-justify-content", animation_value_type="discrete", @@ -117,12 +115,13 @@ ${helpers.single_keyword( )} % endif -% if engine in ["servo-2013", "servo-2020"]: +% if engine == "servo": // FIXME: Update Servo to support the same Syntax as Gecko. ${helpers.single_keyword( "align-content", "stretch flex-start flex-end center space-between space-around", - engines="servo-2013", + engines="servo", + servo_pref="layout.flexbox.enabled", extra_prefixes="webkit", spec="https://drafts.csswg.org/css-align/#propdef-align-content", animation_value_type="discrete", @@ -133,8 +132,8 @@ ${helpers.single_keyword( ${helpers.single_keyword( "align-items", "stretch flex-start flex-end center baseline", - engines="servo-2013 servo-2020", - servo_2020_pref="layout.flexbox.enabled", + engines="servo", + servo_pref="layout.flexbox.enabled", extra_prefixes="webkit", spec="https://drafts.csswg.org/css-flexbox/#align-items-property", animation_value_type="discrete", @@ -195,8 +194,8 @@ ${helpers.predefined_type( "flex-grow", "NonNegativeNumber", "From::from(0.0)", - engines="gecko servo-2013 servo-2020", - servo_2020_pref="layout.flexbox.enabled", + engines="gecko servo", + servo_pref="layout.flexbox.enabled", spec="https://drafts.csswg.org/css-flexbox/#flex-grow-property", extra_prefixes="webkit", animation_value_type="NonNegativeNumber", @@ -208,8 +207,8 @@ ${helpers.predefined_type( "flex-shrink", "NonNegativeNumber", "From::from(1.0)", - engines="gecko servo-2013 servo-2020", - servo_2020_pref="layout.flexbox.enabled", + engines="gecko servo", + servo_pref="layout.flexbox.enabled", spec="https://drafts.csswg.org/css-flexbox/#flex-shrink-property", extra_prefixes="webkit", animation_value_type="NonNegativeNumber", @@ -218,13 +217,13 @@ ${helpers.predefined_type( )} // https://drafts.csswg.org/css-align/#align-self-property -% if engine in ["servo-2013", "servo-2020"]: +% if engine == "servo": // FIXME: Update Servo to support the same syntax as Gecko. ${helpers.single_keyword( "align-self", "auto stretch flex-start flex-end center baseline", - engines="servo-2013 servo-2020", - servo_2020_pref="layout.flexbox.enabled", + engines="servo", + servo_pref="layout.flexbox.enabled", extra_prefixes="webkit", spec="https://drafts.csswg.org/css-flexbox/#propdef-align-self", animation_value_type="discrete", @@ -260,8 +259,8 @@ ${helpers.predefined_type( "order", "Integer", "0", - engines="gecko servo-2013 servo-2020", - servo_2020_pref="layout.flexbox.enabled", + engines="gecko servo", + servo_pref="layout.flexbox.enabled", extra_prefixes="webkit", animation_value_type="ComputedValue", spec="https://drafts.csswg.org/css-flexbox/#order-property", @@ -273,8 +272,8 @@ ${helpers.predefined_type( "flex-basis", "FlexBasis", "computed::FlexBasis::auto()", - engines="gecko servo-2013 servo-2020", - servo_2020_pref="layout.flexbox.enabled", + engines="gecko servo", + servo_pref="layout.flexbox.enabled", spec="https://drafts.csswg.org/css-flexbox/#flex-basis-property", extra_prefixes="webkit", animation_value_type="FlexBasis", @@ -294,7 +293,7 @@ ${helpers.predefined_type( size, "Size", "computed::Size::auto()", - engines="gecko servo-2013 servo-2020", + engines="gecko servo", logical=logical, logical_group="size", allow_quirks="No" if logical else "Yes", @@ -308,7 +307,7 @@ ${helpers.predefined_type( "min-%s" % size, "Size", "computed::Size::auto()", - engines="gecko servo-2013 servo-2020", + engines="gecko servo", logical=logical, logical_group="min-size", allow_quirks="No" if logical else "Yes", @@ -321,7 +320,7 @@ ${helpers.predefined_type( "max-%s" % size, "MaxSize", "computed::MaxSize::none()", - engines="gecko servo-2013 servo-2020", + engines="gecko servo", logical=logical, logical_group="max-size", allow_quirks="No" if logical else "Yes", @@ -335,7 +334,7 @@ ${helpers.predefined_type( ${helpers.single_keyword( "box-sizing", "content-box border-box", - engines="gecko servo-2013 servo-2020", + engines="gecko servo", extra_prefixes="moz:layout.css.prefixes.box-sizing webkit", spec="https://drafts.csswg.org/css-ui/#propdef-box-sizing", gecko_enum_prefix="StyleBoxSizing", @@ -436,9 +435,9 @@ ${helpers.predefined_type( "column-gap", "length::NonNegativeLengthPercentageOrNormal", "computed::length::NonNegativeLengthPercentageOrNormal::normal()", - engines="gecko servo-2013", + engines="gecko servo", aliases="grid-column-gap" if engine == "gecko" else "", - servo_2013_pref="layout.columns.enabled", + servo_pref="layout.columns.enabled", spec="https://drafts.csswg.org/css-align-3/#propdef-column-gap", animation_value_type="NonNegativeLengthPercentageOrNormal", servo_restyle_damage="reflow", @@ -462,7 +461,8 @@ ${helpers.predefined_type( "aspect-ratio", "AspectRatio", "computed::AspectRatio::auto()", - engines="gecko servo-2013", + engines="gecko servo", + servo_pref="layout.legacy_layout", animation_value_type="ComputedValue", spec="https://drafts.csswg.org/css-sizing-4/#aspect-ratio", servo_restyle_damage="reflow", diff --git a/servo/components/style/properties/longhands/svg.mako.rs b/servo/components/style/properties/longhands/svg.mako.rs index 10788d4802..12998d553b 100644 --- a/servo/components/style/properties/longhands/svg.mako.rs +++ b/servo/components/style/properties/longhands/svg.mako.rs @@ -4,8 +4,6 @@ <%namespace name="helpers" file="/helpers.mako.rs" /> -<% data.new_style_struct("SVG", inherited=False, gecko_name="SVGReset") %> - ${helpers.single_keyword( "vector-effect", "none non-scaling-stroke", diff --git a/servo/components/style/properties/longhands/table.mako.rs b/servo/components/style/properties/longhands/table.mako.rs index 3a756636ad..059838bac1 100644 --- a/servo/components/style/properties/longhands/table.mako.rs +++ b/servo/components/style/properties/longhands/table.mako.rs @@ -4,12 +4,11 @@ <%namespace name="helpers" file="/helpers.mako.rs" /> -<% data.new_style_struct("Table", inherited=False) %> - ${helpers.single_keyword( "table-layout", "auto fixed", - engines="gecko servo-2013", + engines="gecko servo", + servo_pref="layout.legacy_layout", gecko_ffi_name="mLayoutStrategy", animation_value_type="discrete", gecko_enum_prefix="StyleTableLayout", diff --git a/servo/components/style/properties/longhands/text.mako.rs b/servo/components/style/properties/longhands/text.mako.rs index 0ee8ba3168..68b8ff3ceb 100644 --- a/servo/components/style/properties/longhands/text.mako.rs +++ b/servo/components/style/properties/longhands/text.mako.rs @@ -3,15 +3,13 @@ * file, You can obtain one at https://mozilla.org/MPL/2.0/. */ <%namespace name="helpers" file="/helpers.mako.rs" /> -<% from data import Method %> - -<% data.new_style_struct("Text", inherited=False, gecko_name="TextReset") %> ${helpers.predefined_type( "text-overflow", "TextOverflow", "computed::TextOverflow::get_initial_value()", - engines="gecko servo-2013", + engines="gecko servo", + servo_pref="layout.legacy_layout", animation_value_type="discrete", boxed=True, spec="https://drafts.csswg.org/css-ui/#propdef-text-overflow", @@ -22,7 +20,8 @@ ${helpers.predefined_type( ${helpers.single_keyword( "unicode-bidi", "normal embed isolate bidi-override isolate-override plaintext", - engines="gecko servo-2013", + engines="gecko servo", + servo_pref="layout.legacy_layout", gecko_enum_prefix="StyleUnicodeBidi", animation_value_type="none", spec="https://drafts.csswg.org/css-writing-modes/#propdef-unicode-bidi", @@ -34,7 +33,7 @@ ${helpers.predefined_type( "text-decoration-line", "TextDecorationLine", "specified::TextDecorationLine::none()", - engines="gecko servo-2013 servo-2020", + engines="gecko servo", initial_specified_value="specified::TextDecorationLine::none()", animation_value_type="discrete", spec="https://drafts.csswg.org/css-text-decor/#propdef-text-decoration-line", @@ -45,7 +44,7 @@ ${helpers.predefined_type( ${helpers.single_keyword( "text-decoration-style", "solid double dotted dashed wavy -moz-none", - engines="gecko servo-2020", + engines="gecko servo", gecko_enum_prefix="StyleTextDecorationStyle", animation_value_type="discrete", spec="https://drafts.csswg.org/css-text-decor/#propdef-text-decoration-style", @@ -56,7 +55,7 @@ ${helpers.predefined_type( "text-decoration-color", "Color", "computed_value::T::currentcolor()", - engines="gecko servo-2020", + engines="gecko servo", initial_specified_value="specified::Color::currentcolor()", animation_value_type="AnimatedColor", ignored_when_colors_disabled=True, diff --git a/servo/components/style/properties/longhands/ui.mako.rs b/servo/components/style/properties/longhands/ui.mako.rs index 58006e0d65..762cb64e9a 100644 --- a/servo/components/style/properties/longhands/ui.mako.rs +++ b/servo/components/style/properties/longhands/ui.mako.rs @@ -3,11 +3,7 @@ * file, You can obtain one at https://mozilla.org/MPL/2.0/. */ <%namespace name="helpers" file="/helpers.mako.rs" /> -<% from data import DEFAULT_RULES_EXCEPT_KEYFRAME, Method %> - -// CSS Basic User Interface Module Level 1 -// https://drafts.csswg.org/css-ui-3/ -<% data.new_style_struct("UI", inherited=False, gecko_name="UIReset") %> +<% from data import DEFAULT_RULES_EXCEPT_KEYFRAME %> // TODO spec says that UAs should not support this // we should probably remove from gecko (https://bugzilla.mozilla.org/show_bug.cgi?id=1328331) @@ -145,7 +141,7 @@ ${helpers.predefined_type( "transition-duration", "Time", "computed::Time::zero()", - engines="gecko servo-2013 servo-2020", + engines="gecko servo", initial_specified_value="specified::Time::zero()", parse_method="parse_non_negative", vector=True, @@ -160,7 +156,7 @@ ${helpers.predefined_type( "transition-timing-function", "TimingFunction", "computed::TimingFunction::ease()", - engines="gecko servo-2013 servo-2020", + engines="gecko servo", initial_specified_value="specified::TimingFunction::ease()", vector=True, need_index=True, @@ -174,7 +170,7 @@ ${helpers.predefined_type( "transition-property", "TransitionProperty", "computed::TransitionProperty::all()", - engines="gecko servo-2013 servo-2020", + engines="gecko servo", initial_specified_value="specified::TransitionProperty::all()", vector=True, none_value="computed::TransitionProperty::none()", @@ -189,7 +185,7 @@ ${helpers.predefined_type( "transition-delay", "Time", "computed::Time::zero()", - engines="gecko servo-2013 servo-2020", + engines="gecko servo", initial_specified_value="specified::Time::zero()", vector=True, need_index=True, @@ -219,7 +215,7 @@ ${helpers.predefined_type( "animation-name", "AnimationName", "computed::AnimationName::none()", - engines="gecko servo-2013 servo-2020", + engines="gecko servo", initial_specified_value="specified::AnimationName::none()", vector=True, need_index=True, @@ -234,7 +230,7 @@ ${helpers.predefined_type( "animation-duration", "Time", "computed::Time::zero()", - engines="gecko servo-2013 servo-2020", + engines="gecko servo", initial_specified_value="specified::Time::zero()", parse_method="parse_non_negative", vector=True, @@ -251,7 +247,7 @@ ${helpers.predefined_type( "animation-timing-function", "TimingFunction", "computed::TimingFunction::ease()", - engines="gecko servo-2013 servo-2020", + engines="gecko servo", initial_specified_value="specified::TimingFunction::ease()", vector=True, need_index=True, @@ -265,7 +261,7 @@ ${helpers.predefined_type( "animation-iteration-count", "AnimationIterationCount", "computed::AnimationIterationCount::one()", - engines="gecko servo-2013 servo-2020", + engines="gecko servo", initial_specified_value="specified::AnimationIterationCount::one()", vector=True, need_index=True, @@ -280,7 +276,7 @@ ${helpers.predefined_type( "animation-direction", "AnimationDirection", "computed::AnimationDirection::Normal", - engines="gecko servo-2013 servo-2020", + engines="gecko servo", initial_specified_value="specified::AnimationDirection::Normal", vector=True, need_index=True, @@ -295,7 +291,7 @@ ${helpers.predefined_type( "animation-play-state", "AnimationPlayState", "computed::AnimationPlayState::Running", - engines="gecko servo-2013 servo-2020", + engines="gecko servo", initial_specified_value="computed::AnimationPlayState::Running", vector=True, need_index=True, @@ -310,7 +306,7 @@ ${helpers.predefined_type( "animation-fill-mode", "AnimationFillMode", "computed::AnimationFillMode::None", - engines="gecko servo-2013 servo-2020", + engines="gecko servo", initial_specified_value="computed::AnimationFillMode::None", vector=True, need_index=True, @@ -325,12 +321,13 @@ ${helpers.predefined_type( "animation-composition", "AnimationComposition", "computed::AnimationComposition::Replace", - engines="gecko", + engines="gecko servo", initial_specified_value="computed::AnimationComposition::Replace", vector=True, need_index=True, animation_value_type="none", gecko_pref="layout.css.animation-composition.enabled", + servo_pref="layout.unimplemented", spec="https://drafts.csswg.org/css-animations-2/#animation-composition", affects="", )} @@ -339,7 +336,7 @@ ${helpers.predefined_type( "animation-delay", "Time", "computed::Time::zero()", - engines="gecko servo-2013 servo-2020", + engines="gecko servo", initial_specified_value="specified::Time::zero()", vector=True, need_index=True, @@ -354,7 +351,8 @@ ${helpers.predefined_type( "animation-timeline", "AnimationTimeline", "computed::AnimationTimeline::auto()", - engines="gecko", + engines="gecko servo", + servo_pref="layout.unimplemented", initial_specified_value="specified::AnimationTimeline::auto()", vector=True, need_index=True, diff --git a/servo/components/style/properties/longhands/xul.mako.rs b/servo/components/style/properties/longhands/xul.mako.rs index 8974ac30dc..f9de8eb239 100644 --- a/servo/components/style/properties/longhands/xul.mako.rs +++ b/servo/components/style/properties/longhands/xul.mako.rs @@ -3,10 +3,6 @@ * file, You can obtain one at https://mozilla.org/MPL/2.0/. */ <%namespace name="helpers" file="/helpers.mako.rs" /> -<% from data import Method %> - -// Non-standard properties that Gecko uses for XUL elements. -<% data.new_style_struct("XUL", inherited=False) %> ${helpers.single_keyword( "-moz-box-align", diff --git a/servo/components/style/properties/mod.rs b/servo/components/style/properties/mod.rs index 7adb6d4ae6..4a08d67f77 100644 --- a/servo/components/style/properties/mod.rs +++ b/servo/components/style/properties/mod.rs @@ -17,12 +17,6 @@ pub use self::generated::*; #[deny(missing_docs)] pub mod generated { include!(concat!(env!("OUT_DIR"), "/properties.rs")); - - #[cfg(feature = "gecko")] - #[allow(unsafe_code, missing_docs)] - pub mod gecko { - include!(concat!(env!("OUT_DIR"), "/gecko_properties.rs")); - } } use crate::custom_properties::{self, ComputedCustomProperties}; @@ -1040,7 +1034,7 @@ impl<'a> PropertyDeclarationId<'a> { pub fn is_discrete_animatable(&self) -> bool { match self { Self::Longhand(longhand) => longhand.is_discrete_animatable(), - // TODO(bug 1846516): Refine this? + // TODO(bug 1885995): Refine this. Self::Custom(_) => true, } } diff --git a/servo/components/style/properties/properties.mako.rs b/servo/components/style/properties/properties.mako.rs index b08314d7d5..e438967c35 100644 --- a/servo/components/style/properties/properties.mako.rs +++ b/servo/components/style/properties/properties.mako.rs @@ -87,10 +87,19 @@ macro_rules! expanded { #[allow(missing_docs)] pub mod longhands { % for style_struct in data.style_structs: - include!("${repr(os.path.join(OUT_DIR, 'longhands/{}.rs'.format(style_struct.name_lower)))[1:-1]}"); + <% data.current_style_struct = style_struct %> + <%include file="/longhands/${style_struct.name_lower}.mako.rs" /> % endfor } + +#[cfg(feature = "gecko")] +#[allow(unsafe_code, missing_docs)] +pub mod gecko { + <%include file="/gecko.mako.rs" /> +} + + macro_rules! unwrap_or_initial { ($prop: ident) => (unwrap_or_initial!($prop, $prop)); ($prop: ident, $expr: expr) => @@ -107,7 +116,7 @@ pub mod shorthands { use crate::values::specified; % for style_struct in data.style_structs: - include!("${repr(os.path.join(OUT_DIR, 'shorthands/{}.rs'.format(style_struct.name_lower)))[1:-1]}"); + <%include file="/shorthands/${style_struct.name_lower}.mako.rs" /> % endfor // We didn't define the 'all' shorthand using the regular helpers:shorthand @@ -142,7 +151,7 @@ pub mod shorthands { data.declare_shorthand( "all", logical_longhands + other_longhands, - engines="gecko servo-2013 servo-2020", + engines="gecko servo", spec="https://drafts.csswg.org/css-cascade-3/#all-shorthand" ) ALL_SHORTHAND_LEN = len(logical_longhands) + len(other_longhands); @@ -505,8 +514,7 @@ impl NonCustomPropertyId { }] = [ % for property in data.longhands + data.shorthands + data.all_aliases(): <% - attrs = {"servo-2013": "servo_2013_pref", "servo-2020": "servo_2020_pref"} - pref = getattr(property, attrs[engine]) + pref = getattr(property, "servo_pref") %> % if pref: Some("${pref}"), @@ -2482,7 +2490,7 @@ impl<'a> StyleBuilder<'a> { } % endif - % if not property.is_vector or property.simple_vector_bindings or engine in ["servo-2013", "servo-2020"]: + % if not property.is_vector or property.simple_vector_bindings or engine == "servo": /// Set the `${property.ident}` to the computed value `value`. #[allow(non_snake_case)] pub fn set_${property.ident}( @@ -2736,7 +2744,13 @@ impl<'a> StyleBuilder<'a> { if matches!(line_height, computed::LineHeight::Normal) { self.add_flags(flag); } - device.calc_line_height(&font, writing_mode, None) + let lh = device.calc_line_height(&font, writing_mode, None); + if line_height_base == LineHeightBase::InheritedStyle { + // Apply our own zoom if our style source is the parent style. + computed::NonNegativeLength::new(self.get_box().clone_zoom().zoom(lh.px())) + } else { + lh + } } /// And access to inherited style structs. @@ -2932,7 +2946,7 @@ const_assert!(std::mem::size_of::<longhands::${longhand.ident}::SpecifiedValue>( % endif % endfor -% if engine in ["servo-2013", "servo-2020"]: +% if engine == "servo": % for effect_name in ["repaint", "reflow_out_of_flow", "reflow", "rebuild_and_reflow_inline", "rebuild_and_reflow"]: macro_rules! restyle_damage_${effect_name} { ($old: ident, $new: ident, $damage: ident, [ $($effect:expr),* ]) => ({ diff --git a/servo/components/style/properties/shorthands/background.mako.rs b/servo/components/style/properties/shorthands/background.mako.rs index 08838233f6..5fee5cb2b0 100644 --- a/servo/components/style/properties/shorthands/background.mako.rs +++ b/servo/components/style/properties/shorthands/background.mako.rs @@ -6,7 +6,7 @@ // TODO: other background-* properties <%helpers:shorthand name="background" - engines="gecko servo-2013 servo-2020" + engines="gecko servo" sub_properties="background-color background-position-x background-position-y background-repeat background-attachment background-image background-size background-origin background-clip" @@ -230,7 +230,7 @@ </%helpers:shorthand> <%helpers:shorthand name="background-position" - engines="gecko servo-2013 servo-2020" + engines="gecko servo" flags="SHORTHAND_IN_GETCS" sub_properties="background-position-x background-position-y" spec="https://drafts.csswg.org/css-backgrounds-4/#the-background-position"> diff --git a/servo/components/style/properties/shorthands/border.mako.rs b/servo/components/style/properties/shorthands/border.mako.rs index c6a87f3197..2eeb691e24 100644 --- a/servo/components/style/properties/shorthands/border.mako.rs +++ b/servo/components/style/properties/shorthands/border.mako.rs @@ -9,7 +9,7 @@ ${helpers.four_sides_shorthand( "border-color", "border-%s-color", "specified::Color::parse", - engines="gecko servo-2013 servo-2020", + engines="gecko servo", spec="https://drafts.csswg.org/css-backgrounds/#border-color", allow_quirks="Yes", )} @@ -17,13 +17,13 @@ ${helpers.four_sides_shorthand( ${helpers.four_sides_shorthand( "border-style", "border-%s-style", - engines="gecko servo-2013 servo-2020", + engines="gecko servo", spec="https://drafts.csswg.org/css-backgrounds/#border-style", )} <%helpers:shorthand name="border-width" - engines="gecko servo-2013 servo-2020" + engines="gecko servo" sub_properties="${ ' '.join('border-%s-width' % side for side in PHYSICAL_SIDES)}" @@ -104,7 +104,7 @@ pub fn parse_border<'i, 't>( %> <%helpers:shorthand name="border-${side}" - engines="gecko servo-2013 servo-2020" + engines="gecko servo" sub_properties="${' '.join( 'border-%s-%s' % (side, prop) for prop in ['width', 'style', 'color'] @@ -139,7 +139,7 @@ pub fn parse_border<'i, 't>( % endfor <%helpers:shorthand name="border" - engines="gecko servo-2013 servo-2020" + engines="gecko servo" sub_properties="${' '.join('border-%s-%s' % (side, prop) for side in PHYSICAL_SIDES for prop in ['width', 'style', 'color'] )} @@ -232,7 +232,7 @@ pub fn parse_border<'i, 't>( <%helpers:shorthand name="border-radius" - engines="gecko servo-2013 servo-2020" + engines="gecko servo" sub_properties="${' '.join( 'border-%s-radius' % (corner) for corner in ['top-left', 'top-right', 'bottom-right', 'bottom-left'] @@ -278,7 +278,8 @@ pub fn parse_border<'i, 't>( <%helpers:shorthand name="border-image" - engines="gecko servo-2013" + engines="gecko servo" + servo_pref="layout.legacy_layout", sub_properties="border-image-outset border-image-repeat border-image-slice border-image-source border-image-width" extra_prefixes="moz:layout.css.prefixes.border-image webkit" @@ -402,7 +403,7 @@ pub fn parse_border<'i, 't>( spec = "https://drafts.csswg.org/css-logical/#propdef-border-%s-%s" % (axis, prop) %> <%helpers:shorthand - engines="gecko servo-2013 servo-2020" + engines="gecko servo" name="border-${axis}-${prop}" sub_properties="${' '.join( 'border-%s-%s-%s' % (axis, side, prop) @@ -448,7 +449,7 @@ pub fn parse_border<'i, 't>( %> <%helpers:shorthand name="border-${axis}" - engines="gecko servo-2013 servo-2020" + engines="gecko servo" sub_properties="${' '.join( 'border-%s-%s-width' % (axis, side) for side in ['start', 'end'] diff --git a/servo/components/style/properties/shorthands/box.mako.rs b/servo/components/style/properties/shorthands/box.mako.rs index f644687dc0..078a511ae9 100644 --- a/servo/components/style/properties/shorthands/box.mako.rs +++ b/servo/components/style/properties/shorthands/box.mako.rs @@ -8,7 +8,7 @@ ${helpers.two_properties_shorthand( "overflow", "overflow-x", "overflow-y", - engines="gecko servo-2013 servo-2020", + engines="gecko servo", flags="SHORTHAND_IN_GETCS", spec="https://drafts.csswg.org/css-overflow/#propdef-overflow", )} @@ -159,13 +159,7 @@ ${helpers.two_properties_shorthand( context: &ParserContext, input: &mut Parser<'i, 't>, ) -> Result<Longhands, ParseError<'i>> { - let offset_position = - if static_prefs::pref!("layout.css.motion-path-offset-position.enabled") { - input.try_parse(|i| OffsetPosition::parse(context, i)).ok() - } else { - None - }; - + let offset_position = input.try_parse(|i| OffsetPosition::parse(context, i)).ok(); let offset_path = input.try_parse(|i| OffsetPath::parse(context, i)).ok(); // Must have one of [offset-position, offset-path]. @@ -212,24 +206,19 @@ ${helpers.two_properties_shorthand( impl<'a> ToCss for LonghandsToSerialize<'a> { fn to_css<W>(&self, dest: &mut CssWriter<W>) -> fmt::Result where W: fmt::Write { - if let Some(offset_position) = self.offset_position { - // The basic concept is: we must serialize offset-position or offset-path group. - // offset-path group means "offset-path offset-distance offset-rotate". - let must_serialize_path = *self.offset_path != OffsetPath::None - || (!self.offset_distance.is_zero() || !self.offset_rotate.is_auto()); - let position_is_default = matches!(offset_position, OffsetPosition::Normal); - if !position_is_default || !must_serialize_path { - offset_position.to_css(dest)?; - } + // The basic concept is: we must serialize offset-position or offset-path group. + // offset-path group means "offset-path offset-distance offset-rotate". + let must_serialize_path = *self.offset_path != OffsetPath::None + || (!self.offset_distance.is_zero() || !self.offset_rotate.is_auto()); + let position_is_default = matches!(self.offset_position, OffsetPosition::Normal); + if !position_is_default || !must_serialize_path { + self.offset_position.to_css(dest)?; + } - if must_serialize_path { - if !position_is_default { - dest.write_char(' ')?; - } - self.offset_path.to_css(dest)?; + if must_serialize_path { + if !position_is_default { + dest.write_char(' ')?; } - } else { - // If the pref is off, we always show offset-path. self.offset_path.to_css(dest)?; } diff --git a/servo/components/style/properties/shorthands/column.mako.rs b/servo/components/style/properties/shorthands/column.mako.rs index 3740775a7e..4cf9a8d786 100644 --- a/servo/components/style/properties/shorthands/column.mako.rs +++ b/servo/components/style/properties/shorthands/column.mako.rs @@ -5,9 +5,9 @@ <%namespace name="helpers" file="/helpers.mako.rs" /> <%helpers:shorthand name="columns" - engines="gecko servo-2013" + engines="gecko servo" sub_properties="column-width column-count" - servo_2013_pref="layout.columns.enabled", + servo_pref="layout.columns.enabled" spec="https://drafts.csswg.org/css-multicol/#propdef-columns"> use crate::properties::longhands::{column_count, column_width}; diff --git a/servo/components/style/properties/shorthands/counters.mako.rs b/servo/components/style/properties/shorthands/counters.mako.rs new file mode 100644 index 0000000000..daa3e8897c --- /dev/null +++ b/servo/components/style/properties/shorthands/counters.mako.rs @@ -0,0 +1,3 @@ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at https://mozilla.org/MPL/2.0/. */ diff --git a/servo/components/style/properties/shorthands/effects.mako.rs b/servo/components/style/properties/shorthands/effects.mako.rs new file mode 100644 index 0000000000..daa3e8897c --- /dev/null +++ b/servo/components/style/properties/shorthands/effects.mako.rs @@ -0,0 +1,3 @@ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at https://mozilla.org/MPL/2.0/. */ diff --git a/servo/components/style/properties/shorthands/font.mako.rs b/servo/components/style/properties/shorthands/font.mako.rs index 17dcf9d926..aaf0895aa5 100644 --- a/servo/components/style/properties/shorthands/font.mako.rs +++ b/servo/components/style/properties/shorthands/font.mako.rs @@ -7,7 +7,7 @@ <%helpers:shorthand name="font" - engines="gecko servo-2013 servo-2020" + engines="gecko servo" sub_properties=" font-style font-variant-caps @@ -321,7 +321,8 @@ </%helpers:shorthand> <%helpers:shorthand name="font-variant" - engines="gecko servo-2013" + engines="gecko servo" + servo_pref="layout.legacy_layout", flags="SHORTHAND_IN_GETCS" sub_properties="font-variant-caps ${'font-variant-alternates' if engine == 'gecko' else ''} diff --git a/servo/components/style/properties/shorthands/inherited_box.mako.rs b/servo/components/style/properties/shorthands/inherited_box.mako.rs new file mode 100644 index 0000000000..daa3e8897c --- /dev/null +++ b/servo/components/style/properties/shorthands/inherited_box.mako.rs @@ -0,0 +1,3 @@ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at https://mozilla.org/MPL/2.0/. */ diff --git a/servo/components/style/properties/shorthands/inherited_table.mako.rs b/servo/components/style/properties/shorthands/inherited_table.mako.rs new file mode 100644 index 0000000000..daa3e8897c --- /dev/null +++ b/servo/components/style/properties/shorthands/inherited_table.mako.rs @@ -0,0 +1,3 @@ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at https://mozilla.org/MPL/2.0/. */ diff --git a/servo/components/style/properties/shorthands/inherited_ui.mako.rs b/servo/components/style/properties/shorthands/inherited_ui.mako.rs new file mode 100644 index 0000000000..daa3e8897c --- /dev/null +++ b/servo/components/style/properties/shorthands/inherited_ui.mako.rs @@ -0,0 +1,3 @@ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at https://mozilla.org/MPL/2.0/. */ diff --git a/servo/components/style/properties/shorthands/list.mako.rs b/servo/components/style/properties/shorthands/list.mako.rs index 2e234e3d8f..183c5ab5da 100644 --- a/servo/components/style/properties/shorthands/list.mako.rs +++ b/servo/components/style/properties/shorthands/list.mako.rs @@ -5,7 +5,7 @@ <%namespace name="helpers" file="/helpers.mako.rs" /> <%helpers:shorthand name="list-style" - engines="gecko servo-2013 servo-2020" + engines="gecko servo" sub_properties="list-style-position list-style-image list-style-type" spec="https://drafts.csswg.org/css-lists/#propdef-list-style"> use crate::properties::longhands::{list_style_image, list_style_position, list_style_type}; @@ -110,7 +110,11 @@ use longhands::list_style_type::SpecifiedValue as ListStyleType; use longhands::list_style_image::SpecifiedValue as ListStyleImage; let mut have_one_non_initial_value = false; - if self.list_style_position != &ListStylePosition::Outside { + #[cfg(feature = "gecko")] + let position_is_initial = self.list_style_position == &ListStylePosition::Outside; + #[cfg(feature = "servo")] + let position_is_initial = matches!(self.list_style_position, None | Some(&ListStylePosition::Outside)); + if !position_is_initial { self.list_style_position.to_css(dest)?; have_one_non_initial_value = true; } @@ -121,7 +125,11 @@ self.list_style_image.to_css(dest)?; have_one_non_initial_value = true; } - if self.list_style_type != &ListStyleType::disc() { + #[cfg(feature = "gecko")] + let type_is_initial = self.list_style_type == &ListStyleType::disc(); + #[cfg(feature = "servo")] + let type_is_initial = self.list_style_type == &ListStyleType::Disc; + if !type_is_initial { if have_one_non_initial_value { dest.write_char(' ')?; } @@ -129,7 +137,14 @@ have_one_non_initial_value = true; } if !have_one_non_initial_value { + #[cfg(feature = "gecko")] self.list_style_position.to_css(dest)?; + #[cfg(feature = "servo")] + if let Some(position) = self.list_style_position { + position.to_css(dest)?; + } else { + self.list_style_type.to_css(dest)?; + } } Ok(()) } diff --git a/servo/components/style/properties/shorthands/margin.mako.rs b/servo/components/style/properties/shorthands/margin.mako.rs index 6b5bf7e467..ba994316a2 100644 --- a/servo/components/style/properties/shorthands/margin.mako.rs +++ b/servo/components/style/properties/shorthands/margin.mako.rs @@ -9,7 +9,7 @@ ${helpers.four_sides_shorthand( "margin", "margin-%s", "specified::LengthPercentageOrAuto::parse", - engines="gecko servo-2013 servo-2020", + engines="gecko servo", spec="https://drafts.csswg.org/css-box/#propdef-margin", rule_types_allowed=DEFAULT_RULES_AND_PAGE, allow_quirks="Yes", @@ -20,7 +20,7 @@ ${helpers.two_properties_shorthand( "margin-block-start", "margin-block-end", "specified::LengthPercentageOrAuto::parse", - engines="gecko servo-2013 servo-2020", + engines="gecko servo", spec="https://drafts.csswg.org/css-logical/#propdef-margin-block" )} @@ -29,7 +29,7 @@ ${helpers.two_properties_shorthand( "margin-inline-start", "margin-inline-end", "specified::LengthPercentageOrAuto::parse", - engines="gecko servo-2013 servo-2020", + engines="gecko servo", spec="https://drafts.csswg.org/css-logical/#propdef-margin-inline" )} diff --git a/servo/components/style/properties/shorthands/outline.mako.rs b/servo/components/style/properties/shorthands/outline.mako.rs index 6ee8ed22c9..ff77e1175e 100644 --- a/servo/components/style/properties/shorthands/outline.mako.rs +++ b/servo/components/style/properties/shorthands/outline.mako.rs @@ -5,7 +5,7 @@ <%namespace name="helpers" file="/helpers.mako.rs" /> <%helpers:shorthand name="outline" - engines="gecko servo-2013" + engines="gecko servo" sub_properties="outline-color outline-style outline-width" spec="https://drafts.csswg.org/css-ui/#propdef-outline"> use crate::properties::longhands::{outline_color, outline_width, outline_style}; diff --git a/servo/components/style/properties/shorthands/padding.mako.rs b/servo/components/style/properties/shorthands/padding.mako.rs index 11ddfed3b1..dad0193708 100644 --- a/servo/components/style/properties/shorthands/padding.mako.rs +++ b/servo/components/style/properties/shorthands/padding.mako.rs @@ -8,7 +8,7 @@ ${helpers.four_sides_shorthand( "padding", "padding-%s", "specified::NonNegativeLengthPercentage::parse", - engines="gecko servo-2013 servo-2020", + engines="gecko servo", spec="https://drafts.csswg.org/css-box-3/#propdef-padding", allow_quirks="Yes", )} @@ -18,7 +18,7 @@ ${helpers.two_properties_shorthand( "padding-block-start", "padding-block-end", "specified::NonNegativeLengthPercentage::parse", - engines="gecko servo-2013 servo-2020", + engines="gecko servo", spec="https://drafts.csswg.org/css-logical/#propdef-padding-block" )} @@ -27,7 +27,7 @@ ${helpers.two_properties_shorthand( "padding-inline-start", "padding-inline-end", "specified::NonNegativeLengthPercentage::parse", - engines="gecko servo-2013 servo-2020", + engines="gecko servo", spec="https://drafts.csswg.org/css-logical/#propdef-padding-inline" )} diff --git a/servo/components/style/properties/shorthands/page.mako.rs b/servo/components/style/properties/shorthands/page.mako.rs new file mode 100644 index 0000000000..daa3e8897c --- /dev/null +++ b/servo/components/style/properties/shorthands/page.mako.rs @@ -0,0 +1,3 @@ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at https://mozilla.org/MPL/2.0/. */ diff --git a/servo/components/style/properties/shorthands/position.mako.rs b/servo/components/style/properties/shorthands/position.mako.rs index ed7df5e27a..ac09bb27d6 100644 --- a/servo/components/style/properties/shorthands/position.mako.rs +++ b/servo/components/style/properties/shorthands/position.mako.rs @@ -5,8 +5,8 @@ <%namespace name="helpers" file="/helpers.mako.rs" /> <%helpers:shorthand name="flex-flow" - engines="gecko servo-2013 servo-2020", - servo_2020_pref="layout.flexbox.enabled", + engines="gecko servo", + servo_pref="layout.flexbox.enabled", sub_properties="flex-direction flex-wrap" extra_prefixes="webkit" spec="https://drafts.csswg.org/css-flexbox/#flex-flow-property"> @@ -60,8 +60,8 @@ </%helpers:shorthand> <%helpers:shorthand name="flex" - engines="gecko servo-2013 servo-2020", - servo_2020_pref="layout.flexbox.enabled", + engines="gecko servo", + servo_pref="layout.flexbox.enabled", sub_properties="flex-grow flex-shrink flex-basis" extra_prefixes="webkit" derive_serialize="True" @@ -858,7 +858,7 @@ ${helpers.four_sides_shorthand( "inset", "%s", "specified::LengthPercentageOrAuto::parse", - engines="gecko servo-2013", + engines="gecko servo", spec="https://drafts.csswg.org/css-logical/#propdef-inset", allow_quirks="No", )} @@ -868,7 +868,7 @@ ${helpers.two_properties_shorthand( "inset-block-start", "inset-block-end", "specified::LengthPercentageOrAuto::parse", - engines="gecko servo-2013", + engines="gecko servo", spec="https://drafts.csswg.org/css-logical/#propdef-inset-block" )} @@ -877,7 +877,7 @@ ${helpers.two_properties_shorthand( "inset-inline-start", "inset-inline-end", "specified::LengthPercentageOrAuto::parse", - engines="gecko servo-2013", + engines="gecko servo", spec="https://drafts.csswg.org/css-logical/#propdef-inset-inline" )} diff --git a/servo/components/style/properties/shorthands/table.mako.rs b/servo/components/style/properties/shorthands/table.mako.rs new file mode 100644 index 0000000000..daa3e8897c --- /dev/null +++ b/servo/components/style/properties/shorthands/table.mako.rs @@ -0,0 +1,3 @@ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at https://mozilla.org/MPL/2.0/. */ diff --git a/servo/components/style/properties/shorthands/text.mako.rs b/servo/components/style/properties/shorthands/text.mako.rs index 5b071be2c4..a913f81875 100644 --- a/servo/components/style/properties/shorthands/text.mako.rs +++ b/servo/components/style/properties/shorthands/text.mako.rs @@ -5,7 +5,7 @@ <%namespace name="helpers" file="/helpers.mako.rs" /> <%helpers:shorthand name="text-decoration" - engines="gecko servo-2013 servo-2020" + engines="gecko servo" flags="SHORTHAND_IN_GETCS" sub_properties="text-decoration-line ${' text-decoration-style text-decoration-color text-decoration-thickness' if engine == 'gecko' else ''}" diff --git a/servo/components/style/properties/shorthands/ui.mako.rs b/servo/components/style/properties/shorthands/ui.mako.rs index 4a27d5e003..1915c65a63 100644 --- a/servo/components/style/properties/shorthands/ui.mako.rs +++ b/servo/components/style/properties/shorthands/ui.mako.rs @@ -18,7 +18,7 @@ macro_rules! try_parse_one { } <%helpers:shorthand name="transition" - engines="gecko servo-2013 servo-2020" + engines="gecko servo" extra_prefixes="moz:layout.css.prefixes.transitions webkit" sub_properties="transition-property transition-duration transition-timing-function @@ -204,7 +204,7 @@ macro_rules! try_parse_one { </%helpers:shorthand> <%helpers:shorthand name="animation" - engines="gecko servo-2013 servo-2020" + engines="gecko servo" extra_prefixes="moz:layout.css.prefixes.animations webkit" sub_properties="animation-name animation-duration animation-timing-function animation-delay @@ -295,6 +295,13 @@ macro_rules! try_parse_one { impl<'a> ToCss for LonghandsToSerialize<'a> { fn to_css<W>(&self, dest: &mut CssWriter<W>) -> fmt::Result where W: fmt::Write { + use crate::values::specified::easing::TimingFunction; + use crate::values::specified::{ + AnimationDirection, AnimationFillMode, AnimationPlayState, + }; + use crate::Zero; + use style_traits::values::SequenceWriter; + let len = self.animation_name.0.len(); // There should be at least one declared value if len == 0 { @@ -320,28 +327,83 @@ macro_rules! try_parse_one { dest.write_str(", ")?; } - % for name in props[2:]: - self.animation_${name}.0[i].to_css(dest)?; - dest.write_char(' ')?; + // We follow the order of this syntax: + // <single-animation> = + // <animation-duration> || + // <easing-function> || + // <animation-delay> || + // <single-animation-iteration-count> || + // <single-animation-direction> || + // <single-animation-fill-mode> || + // <single-animation-play-state> || + // [ none | <keyframes-name> ] || + // <single-animation-timeline> + // + // https://drafts.csswg.org/css-animations-2/#animation-shorthand + // + // FIXME: Bug 1804574. The initial value of duration should be auto, per + // css-animations-2. + let has_duration = !self.animation_duration.0[i].is_zero(); + let has_timing_function = !self.animation_timing_function.0[i].is_ease(); + let has_delay = !self.animation_delay.0[i].is_zero(); + let has_iteration_count = !self.animation_iteration_count.0[i].is_one(); + let has_direction = + !matches!(self.animation_direction.0[i], AnimationDirection::Normal); + let has_fill_mode = + !matches!(self.animation_fill_mode.0[i], AnimationFillMode::None); + let has_play_state = + !matches!(self.animation_play_state.0[i], AnimationPlayState::Running); + let animation_name = &self.animation_name.0[i]; + let has_name = !animation_name.is_none(); + let has_timeline = match self.animation_timeline { + Some(timeline) => !timeline.0[i].is_auto(), + _ => false, + }; + + let mut writer = SequenceWriter::new(dest, " "); + + // To avoid ambiguity, we have to serialize duration if both duration is initial + // but delay is not. (In other words, it's ambiguous if we serialize delay only.) + if has_duration || has_delay { + writer.item(&self.animation_duration.0[i])?; + } + + if has_timing_function || TimingFunction::match_keywords(animation_name) { + writer.item(&self.animation_timing_function.0[i])?; + } + + // For animation-delay and animation-iteration-count. + % for name in props[4:6]: + if has_${name} { + writer.item(&self.animation_${name}.0[i])?; + } % endfor - self.animation_name.0[i].to_css(dest)?; + if has_direction || AnimationDirection::match_keywords(animation_name) { + writer.item(&self.animation_direction.0[i])?; + } + + if has_fill_mode || AnimationFillMode::match_keywords(animation_name) { + writer.item(&self.animation_fill_mode.0[i])?; + } - // Based on the spec, the default values of other properties must be output in at - // least the cases necessary to distinguish an animation-name. The serialization - // order of animation-timeline is always later than animation-name, so it's fine - // to not serialize it if it is the default value. It's still possible to - // distinguish them (because we always serialize animation-name). - // https://drafts.csswg.org/css-animations-1/#animation - // https://drafts.csswg.org/css-animations-2/#typedef-single-animation - // - // Note: it's also fine to always serialize this. However, it seems Blink - // doesn't serialize default animation-timeline now, so we follow the same rule. - if let Some(ref timeline) = self.animation_timeline { - if !timeline.0[i].is_auto() { - dest.write_char(' ')?; - timeline.0[i].to_css(dest)?; - } + if has_play_state || AnimationPlayState::match_keywords(animation_name) { + writer.item(&self.animation_play_state.0[i])?; + } + + // If all values are initial, we must serialize animation-name. + let has_any = { + has_timeline + % for name in props[2:]: + || has_${name} + % endfor + }; + if has_name || !has_any { + writer.item(animation_name)?; + } + + if has_timeline { + writer.item(&self.animation_timeline.unwrap().0[i])?; } } Ok(()) diff --git a/servo/components/style/properties/shorthands/xul.mako.rs b/servo/components/style/properties/shorthands/xul.mako.rs new file mode 100644 index 0000000000..daa3e8897c --- /dev/null +++ b/servo/components/style/properties/shorthands/xul.mako.rs @@ -0,0 +1,3 @@ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at https://mozilla.org/MPL/2.0/. */ diff --git a/servo/components/style/queries/condition.rs b/servo/components/style/queries/condition.rs index e17e6abd2e..25af4cdb01 100644 --- a/servo/components/style/queries/condition.rs +++ b/servo/components/style/queries/condition.rs @@ -13,6 +13,7 @@ use crate::{error_reporting::ContextualParseError, parser::ParserContext}; use cssparser::{Parser, Token}; use std::fmt::{self, Write}; use style_traits::{CssWriter, ParseError, StyleParseErrorKind, ToCss}; +use selectors::kleene_value::KleeneValue; /// A binary `and` or `or` operator. #[derive(Clone, Copy, Debug, Eq, MallocSizeOf, Parse, PartialEq, ToCss, ToShmem)] @@ -29,93 +30,6 @@ enum AllowOr { No, } -/// https://en.wikipedia.org/wiki/Three-valued_logic#Kleene_and_Priest_logics -#[derive(Clone, Copy, Debug, Eq, MallocSizeOf, PartialEq, ToCss)] -pub enum KleeneValue { - /// False - False = 0, - /// True - True = 1, - /// Either true or false, but we’re not sure which yet. - Unknown, -} - -impl From<bool> for KleeneValue { - fn from(b: bool) -> Self { - if b { - Self::True - } else { - Self::False - } - } -} - -impl KleeneValue { - /// Turns this Kleene value to a bool, taking the unknown value as an - /// argument. - pub fn to_bool(self, unknown: bool) -> bool { - match self { - Self::True => true, - Self::False => false, - Self::Unknown => unknown, - } - } -} - -impl std::ops::Not for KleeneValue { - type Output = Self; - - fn not(self) -> Self { - match self { - Self::True => Self::False, - Self::False => Self::True, - Self::Unknown => Self::Unknown, - } - } -} - -// Implements the logical and operation. -impl std::ops::BitAnd for KleeneValue { - type Output = Self; - - fn bitand(self, other: Self) -> Self { - if self == Self::False || other == Self::False { - return Self::False; - } - if self == Self::Unknown || other == Self::Unknown { - return Self::Unknown; - } - Self::True - } -} - -// Implements the logical or operation. -impl std::ops::BitOr for KleeneValue { - type Output = Self; - - fn bitor(self, other: Self) -> Self { - if self == Self::True || other == Self::True { - return Self::True; - } - if self == Self::Unknown || other == Self::Unknown { - return Self::Unknown; - } - Self::False - } -} - -impl std::ops::BitOrAssign for KleeneValue { - fn bitor_assign(&mut self, other: Self) { - *self = *self | other; - } -} - -impl std::ops::BitAndAssign for KleeneValue { - fn bitand_assign(&mut self, other: Self) { - *self = *self & other; - } -} - /// Represents a condition. #[derive(Clone, Debug, MallocSizeOf, PartialEq, ToShmem)] pub enum QueryCondition { diff --git a/servo/components/style/queries/feature.rs b/servo/components/style/queries/feature.rs index 83ff7e7522..2d4c60c362 100644 --- a/servo/components/style/queries/feature.rs +++ b/servo/components/style/queries/feature.rs @@ -4,7 +4,6 @@ //! Query features. -use super::condition::KleeneValue; use crate::parser::ParserContext; use crate::values::computed::{self, CSSPixelLength, Ratio, Resolution}; use crate::values::AtomString; @@ -12,6 +11,7 @@ use crate::Atom; use cssparser::Parser; use std::fmt; use style_traits::ParseError; +use selectors::kleene_value::KleeneValue; /// A generic discriminant for an enum value. pub type KeywordDiscriminant = u8; @@ -87,12 +87,12 @@ macro_rules! keyword_evaluator { fn __evaluate( context: &$crate::values::computed::Context, value: Option<$crate::queries::feature::KeywordDiscriminant>, - ) -> $crate::queries::condition::KleeneValue { + ) -> selectors::kleene_value::KleeneValue { // This unwrap is ok because the only discriminants that get // back to us is the ones that `parse` produces. let value: Option<$keyword_type> = value.map(|kw| ::num_traits::cast::FromPrimitive::from_u8(kw).unwrap()); - $crate::queries::condition::KleeneValue::from($actual_evaluator(context, value)) + selectors::kleene_value::KleeneValue::from($actual_evaluator(context, value)) } $crate::queries::feature::Evaluator::Enumerated { diff --git a/servo/components/style/queries/feature_expression.rs b/servo/components/style/queries/feature_expression.rs index c0171c2058..3450f85cba 100644 --- a/servo/components/style/queries/feature_expression.rs +++ b/servo/components/style/queries/feature_expression.rs @@ -8,16 +8,16 @@ use super::feature::{Evaluator, QueryFeatureDescription}; use super::feature::{FeatureFlags, KeywordDiscriminant}; use crate::parser::{Parse, ParserContext}; -use crate::queries::condition::KleeneValue; use crate::str::{starts_with_ignore_ascii_case, string_as_ascii_lowercase}; use crate::values::computed::{self, Ratio, ToComputedValue}; use crate::values::specified::{Integer, Length, Number, Resolution}; use crate::values::{AtomString, CSSFloat}; use crate::{Atom, Zero}; use cssparser::{Parser, Token}; -use std::cmp::{Ordering, PartialOrd}; +use std::cmp::Ordering; use std::fmt::{self, Write}; use style_traits::{CssWriter, ParseError, StyleParseErrorKind, ToCss}; +use selectors::kleene_value::KleeneValue; /// Whether we're parsing a media or container query feature. #[derive(Clone, Copy, Debug, Eq, MallocSizeOf, PartialEq, ToShmem)] diff --git a/servo/components/style/scoped_tls.rs b/servo/components/style/scoped_tls.rs index 0d3267397a..6fb8730d18 100644 --- a/servo/components/style/scoped_tls.rs +++ b/servo/components/style/scoped_tls.rs @@ -8,7 +8,6 @@ #![deny(missing_docs)] use crate::global_style_data::STYLO_MAX_THREADS; -use rayon; use std::cell::{Ref, RefCell, RefMut}; use std::ops::DerefMut; diff --git a/servo/components/style/str.rs b/servo/components/style/str.rs index 9badcdf413..fe598f546e 100644 --- a/servo/components/style/str.rs +++ b/servo/components/style/str.rs @@ -8,7 +8,6 @@ use num_traits::ToPrimitive; use std::borrow::Cow; -use std::convert::AsRef; use std::iter::{Filter, Peekable}; use std::str::Split; diff --git a/servo/components/style/style_adjuster.rs b/servo/components/style/style_adjuster.rs index a993d79d6a..78a631ec14 100644 --- a/servo/components/style/style_adjuster.rs +++ b/servo/components/style/style_adjuster.rs @@ -294,11 +294,9 @@ impl<'a, 'b: 'a> StyleAdjuster<'a, 'b> { .add_flags(ComputedValueFlags::SELF_OR_ANCESTOR_HAS_SIZE_CONTAINER_TYPE); } - #[cfg(feature = "servo-layout-2013")] - { - if self.style.get_parent_column().is_multicol() { - self.style.add_flags(ComputedValueFlags::CAN_BE_FRAGMENTED); - } + #[cfg(feature = "servo")] + if self.style.get_parent_column().is_multicol() { + self.style.add_flags(ComputedValueFlags::CAN_BE_FRAGMENTED); } } diff --git a/servo/components/style/stylesheets/container_rule.rs b/servo/components/style/stylesheets/container_rule.rs index 28c387fde2..77dfa0e179 100644 --- a/servo/components/style/stylesheets/container_rule.rs +++ b/servo/components/style/stylesheets/container_rule.rs @@ -11,7 +11,6 @@ use crate::dom::TElement; use crate::logical_geometry::{LogicalSize, WritingMode}; use crate::parser::ParserContext; use crate::properties::ComputedValues; -use crate::queries::condition::KleeneValue; use crate::queries::feature::{AllowsRanges, Evaluator, FeatureFlags, QueryFeatureDescription}; use crate::queries::values::Orientation; use crate::queries::{FeatureType, QueryCondition}; @@ -31,6 +30,7 @@ use malloc_size_of::{MallocSizeOfOps, MallocUnconditionalShallowSizeOf}; use servo_arc::Arc; use std::fmt::{self, Write}; use style_traits::{CssWriter, ParseError, ToCss}; +use selectors::kleene_value::KleeneValue; /// A container rule. #[derive(Debug, ToShmem)] diff --git a/servo/components/style/stylesheets/import_rule.rs b/servo/components/style/stylesheets/import_rule.rs index e96134b436..d539471590 100644 --- a/servo/components/style/stylesheets/import_rule.rs +++ b/servo/components/style/stylesheets/import_rule.rs @@ -20,7 +20,7 @@ use crate::values::CssUrl; use cssparser::{Parser, SourceLocation}; use std::fmt::{self, Write}; use style_traits::{CssWriter, ToCss}; -use to_shmem::{self, SharedMemoryBuilder, ToShmem}; +use to_shmem::{SharedMemoryBuilder, ToShmem}; /// A sheet that is held from an import rule. #[cfg(feature = "gecko")] diff --git a/servo/components/style/stylesheets/mod.rs b/servo/components/style/stylesheets/mod.rs index 2bf75565de..6bb8e19fb4 100644 --- a/servo/components/style/stylesheets/mod.rs +++ b/servo/components/style/stylesheets/mod.rs @@ -23,15 +23,17 @@ mod property_rule; mod rule_list; mod rule_parser; mod rules_iterator; +mod starting_style_rule; mod style_rule; mod stylesheet; pub mod supports_rule; +mod scope_rule; #[cfg(feature = "gecko")] use crate::gecko_bindings::sugar::refptr::RefCounted; #[cfg(feature = "gecko")] use crate::gecko_bindings::{bindings, structs}; -use crate::parser::ParserContext; +use crate::parser::{NestingContext, ParserContext}; use crate::shared_lock::{DeepCloneParams, DeepCloneWithLock, Locked}; use crate::shared_lock::{SharedRwLock, SharedRwLockReadGuard, ToCssWithGuard}; use crate::str::CssStringWriter; @@ -45,7 +47,7 @@ use std::fmt; use std::mem::{self, ManuallyDrop}; use style_traits::ParsingMode; #[cfg(feature = "gecko")] -use to_shmem::{self, SharedMemoryBuilder, ToShmem}; +use to_shmem::{SharedMemoryBuilder, ToShmem}; pub use self::container_rule::ContainerRule; pub use self::counter_style_rule::CounterStyleRule; @@ -69,7 +71,9 @@ pub use self::rules_iterator::{AllRules, EffectiveRules}; pub use self::rules_iterator::{ EffectiveRulesIterator, NestedRuleIterationCondition, RulesIterator, }; +pub use self::starting_style_rule::StartingStyleRule; pub use self::style_rule::StyleRule; +pub use self::scope_rule::ScopeRule; pub use self::stylesheet::{AllowImportRules, SanitizationData, SanitizationKind}; pub use self::stylesheet::{DocumentStyleSheet, Namespaces, Stylesheet}; pub use self::stylesheet::{StylesheetContents, StylesheetInDocument, UserAgentStylesheets}; @@ -132,7 +136,11 @@ impl Drop for UrlExtraData { impl ToShmem for UrlExtraData { fn to_shmem(&self, _builder: &mut SharedMemoryBuilder) -> to_shmem::Result<Self> { if self.0 & 1 == 0 { - let shared_extra_datas = unsafe { &structs::URLExtraData_sShared }; + let shared_extra_datas = unsafe { + std::ptr::addr_of!(structs::URLExtraData_sShared) + .as_ref() + .unwrap() + }; let self_ptr = self.as_ref() as *const _ as *mut _; let sheet_id = shared_extra_datas .iter() @@ -265,6 +273,8 @@ pub enum CssRule { Document(Arc<DocumentRule>), LayerBlock(Arc<LayerBlockRule>), LayerStatement(Arc<LayerStatementRule>), + Scope(Arc<ScopeRule>), + StartingStyle(Arc<StartingStyleRule>), } impl CssRule { @@ -309,8 +319,14 @@ impl CssRule { CssRule::Document(ref arc) => { arc.unconditional_shallow_size_of(ops) + arc.size_of(guard, ops) }, + CssRule::StartingStyle(ref arc) => { + arc.unconditional_shallow_size_of(ops) + arc.size_of(guard, ops) + } // TODO(emilio): Add memory reporting for these rules. CssRule::LayerBlock(_) | CssRule::LayerStatement(_) => 0, + CssRule::Scope(ref rule) => { + rule.unconditional_shallow_size_of(ops) + rule.size_of(guard, ops) + } } } } @@ -349,6 +365,9 @@ pub enum CssRuleType { FontPaletteValues = 19, // 20 is an arbitrary number to use for Property. Property = 20, + Scope = 21, + // https://drafts.csswg.org/css-transitions-2/#the-cssstartingstylerule-interface + StartingStyle = 22, } impl CssRuleType { @@ -436,6 +455,8 @@ impl CssRule { CssRule::LayerBlock(_) => CssRuleType::LayerBlock, CssRule::LayerStatement(_) => CssRuleType::LayerStatement, CssRule::Container(_) => CssRuleType::Container, + CssRule::Scope(_) => CssRuleType::Scope, + CssRule::StartingStyle(_) => CssRuleType::StartingStyle, } } @@ -464,7 +485,11 @@ impl CssRule { None, None, ); - context.rule_types = insert_rule_context.containing_rule_types; + // Override the nesting context with existing data. + context.nesting_context = NestingContext::new( + insert_rule_context.containing_rule_types, + insert_rule_context.parse_relative_rule_type + ); let state = if !insert_rule_context.containing_rule_types.is_empty() { State::Body @@ -567,6 +592,12 @@ impl DeepCloneWithLock for CssRule { CssRule::LayerBlock(ref arc) => { CssRule::LayerBlock(Arc::new(arc.deep_clone_with_lock(lock, guard, params))) }, + CssRule::Scope(ref arc) => { + CssRule::Scope(Arc::new(arc.deep_clone_with_lock(lock, guard, params))) + }, + CssRule::StartingStyle(ref arc) => { + CssRule::StartingStyle(Arc::new(arc.deep_clone_with_lock(lock, guard, params))) + }, } } } @@ -592,6 +623,8 @@ impl ToCssWithGuard for CssRule { CssRule::LayerBlock(ref rule) => rule.to_css(guard, dest), CssRule::LayerStatement(ref rule) => rule.to_css(guard, dest), CssRule::Container(ref rule) => rule.to_css(guard, dest), + CssRule::Scope(ref rule) => rule.to_css(guard, dest), + CssRule::StartingStyle(ref rule) => rule.to_css(guard, dest), } } } diff --git a/servo/components/style/stylesheets/page_rule.rs b/servo/components/style/stylesheets/page_rule.rs index a1618309a3..cdcfe0b8a7 100644 --- a/servo/components/style/stylesheets/page_rule.rs +++ b/servo/components/style/stylesheets/page_rule.rs @@ -221,7 +221,7 @@ impl Parse for PageSelector { ) -> Result<Self, ParseError<'i>> { let name = input .try_parse(parse_page_name) - .unwrap_or(AtomIdent(atom!(""))); + .unwrap_or(AtomIdent::new(atom!(""))); let mut pseudos = PagePseudoClasses::default(); while let Ok(pc) = input.try_parse(PagePseudoClass::parse) { pseudos.push(pc); diff --git a/servo/components/style/stylesheets/rule_list.rs b/servo/components/style/stylesheets/rule_list.rs index 1b9f330185..9fb7629d3d 100644 --- a/servo/components/style/stylesheets/rule_list.rs +++ b/servo/components/style/stylesheets/rule_list.rs @@ -16,6 +16,8 @@ use malloc_size_of::{MallocShallowSizeOf, MallocSizeOfOps}; use servo_arc::Arc; use std::fmt::{self, Write}; +use super::CssRuleType; + /// A list of CSS rules. #[derive(Debug, ToShmem)] pub struct CssRules(pub Vec<CssRule>); @@ -136,6 +138,7 @@ pub trait CssRulesHelpers { parent_stylesheet_contents: &StylesheetContents, index: usize, nested: CssRuleTypes, + parse_relative_rule_type: Option<CssRuleType>, loader: Option<&dyn StylesheetLoader>, allow_import_rules: AllowImportRules, ) -> Result<CssRule, RulesMutateError>; @@ -149,6 +152,7 @@ impl CssRulesHelpers for Locked<CssRules> { parent_stylesheet_contents: &StylesheetContents, index: usize, containing_rule_types: CssRuleTypes, + parse_relative_rule_type: Option<CssRuleType>, loader: Option<&dyn StylesheetLoader>, allow_import_rules: AllowImportRules, ) -> Result<CssRule, RulesMutateError> { @@ -165,6 +169,7 @@ impl CssRulesHelpers for Locked<CssRules> { rule_list: &rules.0, index, containing_rule_types, + parse_relative_rule_type, }; // Steps 3, 4, 5, 6 diff --git a/servo/components/style/stylesheets/rule_parser.rs b/servo/components/style/stylesheets/rule_parser.rs index 742ad5d250..634f7c1af3 100644 --- a/servo/components/style/stylesheets/rule_parser.rs +++ b/servo/components/style/stylesheets/rule_parser.rs @@ -23,6 +23,8 @@ use crate::stylesheets::font_feature_values_rule::parse_family_name_list; use crate::stylesheets::import_rule::{ImportLayer, ImportRule, ImportSupportsCondition}; use crate::stylesheets::keyframes_rule::parse_keyframe_list; use crate::stylesheets::layer_rule::{LayerBlockRule, LayerName, LayerStatementRule}; +use crate::stylesheets::scope_rule::{ScopeBounds, ScopeRule}; +use crate::stylesheets::starting_style_rule::StartingStyleRule; use crate::stylesheets::supports_rule::SupportsCondition; use crate::stylesheets::{ AllowImportRules, CorsMode, CssRule, CssRuleType, CssRuleTypes, CssRules, DocumentRule, @@ -50,6 +52,8 @@ pub struct InsertRuleContext<'a> { pub index: usize, /// The containing rule types of our ancestors. pub containing_rule_types: CssRuleTypes, + /// Rule type determining if and how we parse relative selector syntax. + pub parse_relative_rule_type: Option<CssRuleType>, } impl<'a> InsertRuleContext<'a> { @@ -231,6 +235,10 @@ pub enum AtRulePrelude { Namespace(Option<Prefix>, Namespace), /// A @layer rule prelude. Layer(Vec<LayerName>), + /// A @scope rule prelude. + Scope(ScopeBounds), + /// A @starting-style prelude. + StartingStyle, } impl AtRulePrelude { @@ -251,6 +259,8 @@ impl AtRulePrelude { Self::Margin(..) => "margin", Self::Namespace(..) => "namespace", Self::Layer(..) => "layer", + Self::Scope(..) => "scope", + Self::StartingStyle => "starting-style", } } } @@ -483,18 +493,29 @@ impl NestedParseResult { impl<'a, 'i> NestedRuleParser<'a, 'i> { #[inline] fn in_style_rule(&self) -> bool { - self.context.rule_types.contains(CssRuleType::Style) + self.context + .nesting_context + .rule_types + .contains(CssRuleType::Style) } #[inline] fn in_page_rule(&self) -> bool { - self.context.rule_types.contains(CssRuleType::Page) + self.context + .nesting_context + .rule_types + .contains(CssRuleType::Page) } #[inline] fn in_style_or_page_rule(&self) -> bool { let types = CssRuleTypes::from_bits(CssRuleType::Style.bit() | CssRuleType::Page.bit()); - self.context.rule_types.intersects(types) + self.context.nesting_context.rule_types.intersects(types) + } + + #[inline] + fn parse_relative(&self) -> ParseRelative { + self.context.nesting_context.parse_relative } // https://drafts.csswg.org/css-nesting/#conditionals @@ -507,7 +528,9 @@ impl<'a, 'i> NestedRuleParser<'a, 'i> { AtRulePrelude::Supports(..) | AtRulePrelude::Container(..) | AtRulePrelude::Document(..) | - AtRulePrelude::Layer(..) => true, + AtRulePrelude::Layer(..) | + AtRulePrelude::Scope(..) | + AtRulePrelude::StartingStyle => true, AtRulePrelude::Namespace(..) | AtRulePrelude::FontFace | @@ -523,10 +546,9 @@ impl<'a, 'i> NestedRuleParser<'a, 'i> { } fn nest_for_rule<R>(&mut self, rule_type: CssRuleType, cb: impl FnOnce(&mut Self) -> R) -> R { - let old_rule_types = self.context.rule_types; - self.context.rule_types.insert(rule_type); + let old = self.context.nesting_context.save(rule_type); let r = cb(self); - self.context.rule_types = old_rule_types; + self.context.nesting_context.restore(old); r } @@ -701,6 +723,13 @@ impl<'a, 'i> AtRuleParser<'i> for NestedRuleParser<'a, 'i> { let cond = DocumentCondition::parse(&self.context, input)?; AtRulePrelude::Document(cond) }, + "scope" if static_prefs::pref!("layout.css.at-scope.enabled") => { + let bounds = ScopeBounds::parse(&self.context, input, self.in_style_rule()); + AtRulePrelude::Scope(bounds) + }, + "starting-style" if static_prefs::pref!("layout.css.starting-style-at-rules.enabled") => { + AtRulePrelude::StartingStyle + }, _ => { if static_prefs::pref!("layout.css.margin-rules.enabled") { if let Some(margin_rule_type) = MarginRuleType::match_name(&name) { @@ -862,11 +891,30 @@ impl<'a, 'i> AtRuleParser<'i> for NestedRuleParser<'a, 'i> { block: Arc::new(self.shared_lock.wrap(declarations)), source_location: start.source_location(), })) - } + }, AtRulePrelude::Import(..) | AtRulePrelude::Namespace(..) => { // These rules don't have blocks. return Err(input.new_unexpected_token_error(cssparser::Token::CurlyBracketBlock)); }, + AtRulePrelude::Scope(bounds) => { + let source_location = start.source_location(); + CssRule::Scope(Arc::new(ScopeRule { + bounds, + rules: self + .parse_nested(input, CssRuleType::Scope) + .into_rules(self.shared_lock, source_location), + source_location, + })) + }, + AtRulePrelude::StartingStyle => { + let source_location = start.source_location(); + CssRule::StartingStyle(Arc::new(StartingStyleRule { + rules: self + .parse_nested(input, CssRuleType::StartingStyle) + .into_rules(self.shared_lock, source_location), + source_location, + })) + }, }; self.rules.push(rule); Ok(()) @@ -913,12 +961,7 @@ impl<'a, 'i> QualifiedRuleParser<'i> for NestedRuleParser<'a, 'i> { url_data: self.context.url_data, for_supports_rule: false, }; - let parse_relative = if self.in_style_rule() { - ParseRelative::ForNesting - } else { - ParseRelative::No - }; - SelectorList::parse(&selector_parser, input, parse_relative) + SelectorList::parse(&selector_parser, input, self.parse_relative()) } fn parse_block<'t>( diff --git a/servo/components/style/stylesheets/rules_iterator.rs b/servo/components/style/stylesheets/rules_iterator.rs index 76d41c8184..60f3df1ea9 100644 --- a/servo/components/style/stylesheets/rules_iterator.rs +++ b/servo/components/style/stylesheets/rules_iterator.rs @@ -116,6 +116,8 @@ where Some(supports_rule.rules.read_with(guard).0.iter()) }, CssRule::LayerBlock(ref layer_rule) => Some(layer_rule.rules.read_with(guard).0.iter()), + CssRule::Scope(ref rule) => Some(rule.rules.read_with(guard).0.iter()), + CssRule::StartingStyle(ref rule) => Some(rule.rules.read_with(guard).0.iter()), } } } diff --git a/servo/components/style/stylesheets/scope_rule.rs b/servo/components/style/stylesheets/scope_rule.rs new file mode 100644 index 0000000000..6816c433a7 --- /dev/null +++ b/servo/components/style/stylesheets/scope_rule.rs @@ -0,0 +1,161 @@ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at https://mozilla.org/MPL/2.0/. */ + +//! A [`@scope`][scope] rule. +//! +//! [scope]: https://drafts.csswg.org/css-cascade-6/#scoped-styles + +use crate::parser::ParserContext; +use crate::selector_parser::{SelectorImpl, SelectorParser}; +use crate::shared_lock::{ + DeepCloneParams, DeepCloneWithLock, Locked, SharedRwLock, SharedRwLockReadGuard, ToCssWithGuard, +}; +use crate::str::CssStringWriter; +use crate::stylesheets::CssRules; +use cssparser::{Parser, SourceLocation, ToCss}; +#[cfg(feature = "gecko")] +use malloc_size_of::{MallocSizeOfOps, MallocUnconditionalSizeOf, MallocUnconditionalShallowSizeOf}; +use selectors::parser::{ParseRelative, SelectorList}; +use servo_arc::Arc; +use std::fmt::{self, Write}; +use style_traits::CssWriter; + +/// A scoped rule. +#[derive(Debug, ToShmem)] +pub struct ScopeRule { + /// Bounds at which this rule applies. + pub bounds: ScopeBounds, + /// The nested rules inside the block. + pub rules: Arc<Locked<CssRules>>, + /// The source position where this rule was found. + pub source_location: SourceLocation, +} + +impl DeepCloneWithLock for ScopeRule { + fn deep_clone_with_lock( + &self, + lock: &SharedRwLock, + guard: &SharedRwLockReadGuard, + params: &DeepCloneParams, + ) -> Self { + let rules = self.rules.read_with(guard); + Self { + bounds: self.bounds.clone(), + rules: Arc::new(lock.wrap(rules.deep_clone_with_lock(lock, guard, params))), + source_location: self.source_location.clone(), + } + } +} + +impl ToCssWithGuard for ScopeRule { + fn to_css(&self, guard: &SharedRwLockReadGuard, dest: &mut CssStringWriter) -> fmt::Result { + dest.write_str("@scope")?; + { + let mut writer = CssWriter::new(dest); + if let Some(start) = self.bounds.start.as_ref() { + writer.write_str(" (")?; + start.to_css(&mut writer)?; + writer.write_char(')')?; + } + if let Some(end) = self.bounds.end.as_ref() { + writer.write_str(" to (")?; + end.to_css(&mut writer)?; + writer.write_char(')')?; + } + } + self.rules.read_with(guard).to_css_block(guard, dest) + } +} + +impl ScopeRule { + /// Measure heap usage. + #[cfg(feature = "gecko")] + pub fn size_of(&self, guard: &SharedRwLockReadGuard, ops: &mut MallocSizeOfOps) -> usize { + self.rules.unconditional_shallow_size_of(ops) + + self.rules.read_with(guard).size_of(guard, ops) + + self.bounds.size_of(ops) + } +} + +/// Bounds of the scope. +#[derive(Debug, Clone, ToShmem)] +pub struct ScopeBounds { + /// Start of the scope. + pub start: Option<SelectorList<SelectorImpl>>, + /// End of the scope. + pub end: Option<SelectorList<SelectorImpl>>, +} + +impl ScopeBounds { + #[cfg(feature = "gecko")] + fn size_of(&self, ops: &mut MallocSizeOfOps) -> usize { + fn bound_size_of(bound: &Option<SelectorList<SelectorImpl>>, ops: &mut MallocSizeOfOps) -> usize { + bound.as_ref().map(|list| list.unconditional_size_of(ops)).unwrap_or(0) + } + bound_size_of(&self.start, ops) + bound_size_of(&self.end, ops) + } +} + +fn parse_scope<'a>( + context: &ParserContext, + input: &mut Parser<'a, '_>, + in_style_rule: bool, + for_end: bool +) -> Option<SelectorList<SelectorImpl>> { + input.try_parse(|input| { + if for_end { + input.expect_ident_matching("to")?; + } + input.expect_parenthesis_block()?; + input.parse_nested_block(|input| { + if input.is_exhausted() { + return Ok(None); + } + let selector_parser = SelectorParser { + stylesheet_origin: context.stylesheet_origin, + namespaces: &context.namespaces, + url_data: context.url_data, + for_supports_rule: false, + }; + let parse_relative = if for_end { + ParseRelative::ForScope + } else if in_style_rule { + ParseRelative::ForNesting + } else { + ParseRelative::No + }; + Ok(Some(SelectorList::parse_forgiving( + &selector_parser, + input, + parse_relative, + )?)) + }) + }) + .ok() + .flatten() +} + +impl ScopeBounds { + /// Parse a container condition. + pub fn parse<'a>( + context: &ParserContext, + input: &mut Parser<'a, '_>, + in_style_rule: bool, + ) -> Self { + let start = parse_scope( + context, + input, + in_style_rule, + false + ); + + let end = parse_scope( + context, + input, + in_style_rule, + true + ); + Self { start, end } + } +} diff --git a/servo/components/style/stylesheets/starting_style_rule.rs b/servo/components/style/stylesheets/starting_style_rule.rs new file mode 100644 index 0000000000..3c2627582b --- /dev/null +++ b/servo/components/style/stylesheets/starting_style_rule.rs @@ -0,0 +1,57 @@ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at https://mozilla.org/MPL/2.0/. */ + +//! before-change style: the `@starting-style` rules. +//! https://drafts.csswg.org/css-transitions-2/#defining-before-change-style + +use crate::shared_lock::{DeepCloneParams, DeepCloneWithLock, Locked}; +use crate::shared_lock::{SharedRwLock, SharedRwLockReadGuard, ToCssWithGuard}; +use crate::str::CssStringWriter; +use crate::stylesheets::CssRules; +use cssparser::SourceLocation; +use malloc_size_of::{MallocSizeOfOps, MallocUnconditionalShallowSizeOf}; +use servo_arc::Arc; +use std::fmt::{self, Debug, Write}; + +/// A [`@starting-style`][starting-style] rule. +/// +/// [starting-style]: https://drafts.csswg.org/css-transitions-2/#at-ruledef-starting-style +#[derive(Debug, ToShmem)] +pub struct StartingStyleRule { + /// The nested rules to this starting-style rule. + pub rules: Arc<Locked<CssRules>>, + /// The source position where this starting-style rule was found. + pub source_location: SourceLocation, +} + +impl StartingStyleRule { + /// Measure heap usage. + #[cfg(feature = "gecko")] + pub fn size_of(&self, guard: &SharedRwLockReadGuard, ops: &mut MallocSizeOfOps) -> usize { + self.rules.unconditional_shallow_size_of(ops) + + self.rules.read_with(guard).size_of(guard, ops) + } +} + +impl ToCssWithGuard for StartingStyleRule { + fn to_css(&self, guard: &SharedRwLockReadGuard, dest: &mut CssStringWriter) -> fmt::Result { + dest.write_str("@starting-style")?; + self.rules.read_with(guard).to_css_block(guard, dest) + } +} + +impl DeepCloneWithLock for StartingStyleRule { + fn deep_clone_with_lock( + &self, + lock: &SharedRwLock, + guard: &SharedRwLockReadGuard, + params: &DeepCloneParams, + ) -> Self { + let rules = self.rules.read_with(guard); + StartingStyleRule { + rules: Arc::new(lock.wrap(rules.deep_clone_with_lock(lock, guard, params))), + source_location: self.source_location.clone(), + } + } +} diff --git a/servo/components/style/stylesheets/stylesheet.rs b/servo/components/style/stylesheets/stylesheet.rs index 1604022871..84d84b0d46 100644 --- a/servo/components/style/stylesheets/stylesheet.rs +++ b/servo/components/style/stylesheets/stylesheet.rs @@ -333,7 +333,11 @@ impl SanitizationKind { // TODO(emilio): Perhaps Layer should not be always sanitized? But // we sanitize @media and co, so this seems safer for now. CssRule::LayerStatement(..) | - CssRule::LayerBlock(..) => false, + CssRule::LayerBlock(..) | + // TODO(dshin): Same comment as Layer applies - shouldn't give away + // something like display size - erring on the side of "safe" for now. + CssRule::Scope(..) | + CssRule::StartingStyle(..) => false, CssRule::FontFace(..) | CssRule::Namespace(..) | CssRule::Style(..) => true, diff --git a/servo/components/style/stylist.rs b/servo/components/style/stylist.rs index cc1cb75689..06cbe6276b 100644 --- a/servo/components/style/stylist.rs +++ b/servo/components/style/stylist.rs @@ -31,7 +31,7 @@ use crate::rule_collector::RuleCollector; use crate::rule_tree::{CascadeLevel, RuleTree, StrongRuleNode, StyleSource}; use crate::sharing::RevalidationResult; use crate::selector_map::{PrecomputedHashMap, PrecomputedHashSet, SelectorMap, SelectorMapEntry}; -use crate::selector_parser::{PerPseudoElementMap, PseudoElement, SelectorImpl, SnapshotMap}; +use crate::selector_parser::{PerPseudoElementMap, PseudoElement, SelectorImpl, NonTSPseudoClass, SnapshotMap}; use crate::shared_lock::{Locked, SharedRwLockReadGuard, StylesheetGuards}; use crate::stylesheet_set::{DataValidity, DocumentStylesheetSet, SheetRebuildKind}; use crate::stylesheet_set::{DocumentStylesheetFlusher, SheetCollectionFlusher}; @@ -48,7 +48,7 @@ use crate::stylesheets::{ PerOriginIter, }; use crate::stylesheets::{StyleRule, StylesheetContents, StylesheetInDocument}; -use crate::values::computed; +use crate::values::{computed, AtomIdent}; use crate::AllocErr; use crate::{Atom, LocalName, Namespace, ShrinkIfNeeded, WeakAtom}; use dom::{DocumentState, ElementState}; @@ -113,8 +113,6 @@ unsafe impl Send for CascadeDataCacheKey {} unsafe impl Sync for CascadeDataCacheKey {} trait CascadeDataCacheEntry: Sized { - /// Returns a reference to the cascade data. - fn cascade_data(&self) -> &CascadeData; /// Rebuilds the cascade data for the new stylesheet collection. The /// collection is guaranteed to be dirty. fn rebuild<S>( @@ -269,10 +267,6 @@ lazy_static! { } impl CascadeDataCacheEntry for UserAgentCascadeData { - fn cascade_data(&self) -> &CascadeData { - &self.cascade_data - } - fn rebuild<S>( device: &Device, quirks_mode: QuirksMode, @@ -2023,6 +2017,11 @@ struct StylistSelectorVisitor<'a> { /// selectors. nth_of_attribute_dependencies: &'a mut PrecomputedHashSet<LocalName>, + /// The filter with the local names of custom states in selectors for + /// within the selector list of :nth-child(... of <selector list>) + /// selectors. + nth_of_custom_state_dependencies: &'a mut PrecomputedHashSet<AtomIdent>, + /// All the states selectors in the page reference. state_dependencies: &'a mut ElementState, @@ -2144,6 +2143,16 @@ impl<'a> SelectorVisitor for StylistSelectorVisitor<'a> { component_needs_revalidation(s, self.passed_rightmost_selector); match *s { + Component::NonTSPseudoClass(NonTSPseudoClass::CustomState(ref name)) => { + // CustomStateSet is special cased as it is a functional pseudo + // class with unbounded inner values. This is different to + // other psuedo class like :emtpy or :dir() which can be packed + // into the ElementState bitflags. For CustomState, however, + // the state name should be checked for presence in the selector. + if self.in_selector_list_of.relevant_to_nth_of_dependencies() { + self.nth_of_custom_state_dependencies.insert(name.0.clone()); + } + }, Component::NonTSPseudoClass(ref p) => { self.state_dependencies.insert(p.state_flag()); self.document_state_dependencies @@ -2377,6 +2386,11 @@ pub struct CascadeData { /// an element when an irrelevant attribute changes. nth_of_attribute_dependencies: PrecomputedHashSet<LocalName>, + /// The custom states that appear in the selector list of + /// :nth-child(... of <selector list>). Used to avoid restyling siblings of + /// an element when an irrelevant custom state changes. + nth_of_custom_state_dependencies: PrecomputedHashSet<AtomIdent>, + /// The element state bits that are relied on by selectors. Like /// `attribute_dependencies`, this is used to avoid taking element snapshots /// when an irrelevant element state bit changes. @@ -2456,6 +2470,7 @@ impl CascadeData { nth_of_mapped_ids: PrecomputedHashSet::default(), nth_of_class_dependencies: PrecomputedHashSet::default(), nth_of_attribute_dependencies: PrecomputedHashSet::default(), + nth_of_custom_state_dependencies: PrecomputedHashSet::default(), nth_of_state_dependencies: ElementState::empty(), attribute_dependencies: PrecomputedHashSet::default(), state_dependencies: ElementState::empty(), @@ -2535,6 +2550,13 @@ impl CascadeData { self.state_dependencies.intersects(state) } + /// Returns whether the given Custom State is relied upon by a selector + /// of some rule in the selector list of :nth-child(... of <selector list>). + #[inline] + pub fn has_nth_of_custom_state_dependency(&self, state: &AtomIdent) -> bool { + self.nth_of_custom_state_dependencies.contains(state) + } + /// Returns whether the given ElementState bit is relied upon by a selector /// of some rule in the selector list of :nth-child(... of <selector list>). #[inline] @@ -2664,6 +2686,7 @@ impl CascadeData { self.relative_selector_invalidation_map.shrink_if_needed(); self.attribute_dependencies.shrink_if_needed(); self.nth_of_attribute_dependencies.shrink_if_needed(); + self.nth_of_custom_state_dependencies.shrink_if_needed(); self.nth_of_class_dependencies.shrink_if_needed(); self.nth_of_mapped_ids.shrink_if_needed(); self.mapped_ids.shrink_if_needed(); @@ -2859,6 +2882,8 @@ impl CascadeData { nth_of_class_dependencies: &mut self.nth_of_class_dependencies, nth_of_attribute_dependencies: &mut self .nth_of_attribute_dependencies, + nth_of_custom_state_dependencies: &mut self + .nth_of_custom_state_dependencies, state_dependencies: &mut self.state_dependencies, nth_of_state_dependencies: &mut self.nth_of_state_dependencies, document_state_dependencies: &mut self.document_state_dependencies, @@ -3234,7 +3259,9 @@ impl CascadeData { CssRule::LayerBlock(..) | CssRule::LayerStatement(..) | CssRule::FontPaletteValues(..) | - CssRule::FontFeatureValues(..) => { + CssRule::FontFeatureValues(..) | + CssRule::Scope(..) | + CssRule::StartingStyle(..) => { // Not affected by device changes. continue; }, @@ -3323,6 +3350,7 @@ impl CascadeData { self.relative_selector_invalidation_map.clear(); self.attribute_dependencies.clear(); self.nth_of_attribute_dependencies.clear(); + self.nth_of_custom_state_dependencies.clear(); self.nth_of_class_dependencies.clear(); self.state_dependencies = ElementState::empty(); self.nth_of_state_dependencies = ElementState::empty(); @@ -3335,10 +3363,6 @@ impl CascadeData { } impl CascadeDataCacheEntry for CascadeData { - fn cascade_data(&self) -> &CascadeData { - self - } - fn rebuild<S>( device: &Device, quirks_mode: QuirksMode, @@ -3482,6 +3506,7 @@ pub fn needs_revalidation_for_testing(s: &Selector<SelectorImpl>) -> bool { let mut attribute_dependencies = Default::default(); let mut nth_of_class_dependencies = Default::default(); let mut nth_of_attribute_dependencies = Default::default(); + let mut nth_of_custom_state_dependencies = Default::default(); let mut state_dependencies = ElementState::empty(); let mut nth_of_state_dependencies = ElementState::empty(); let mut document_state_dependencies = DocumentState::empty(); @@ -3494,6 +3519,7 @@ pub fn needs_revalidation_for_testing(s: &Selector<SelectorImpl>) -> bool { attribute_dependencies: &mut attribute_dependencies, nth_of_class_dependencies: &mut nth_of_class_dependencies, nth_of_attribute_dependencies: &mut nth_of_attribute_dependencies, + nth_of_custom_state_dependencies: &mut nth_of_custom_state_dependencies, state_dependencies: &mut state_dependencies, nth_of_state_dependencies: &mut nth_of_state_dependencies, document_state_dependencies: &mut document_state_dependencies, diff --git a/servo/components/style/traversal.rs b/servo/components/style/traversal.rs index d63c3cb965..fa256d0f60 100644 --- a/servo/components/style/traversal.rs +++ b/servo/components/style/traversal.rs @@ -688,7 +688,7 @@ where element.finish_restyle(context, data, new_styles, important_rules_changed) } -#[cfg(feature = "servo-layout-2013")] +#[cfg(feature = "servo")] fn notify_paint_worklet<E>(context: &StyleContext<E>, data: &ElementData) where E: TElement, @@ -726,7 +726,7 @@ where } } -#[cfg(not(feature = "servo-layout-2013"))] +#[cfg(not(feature = "servo"))] fn notify_paint_worklet<E>(_context: &StyleContext<E>, _data: &ElementData) where E: TElement, diff --git a/servo/components/style/values/computed/basic_shape.rs b/servo/components/style/values/computed/basic_shape.rs index d39110ec1c..21df7baf93 100644 --- a/servo/components/style/values/computed/basic_shape.rs +++ b/servo/components/style/values/computed/basic_shape.rs @@ -7,9 +7,12 @@ //! //! [basic-shape]: https://drafts.csswg.org/css-shapes/#typedef-basic-shape +use crate::values::animated::{Animate, Procedure}; +use crate::values::computed::angle::Angle; use crate::values::computed::url::ComputedUrl; use crate::values::computed::{Image, LengthPercentage, NonNegativeLengthPercentage, Position}; use crate::values::generics::basic_shape as generic; +use crate::values::specified::svg_path::{CoordPair, PathCommand}; /// A computed alias for FillRule. pub use crate::values::generics::basic_shape::FillRule; @@ -21,8 +24,13 @@ pub type ClipPath = generic::GenericClipPath<BasicShape, ComputedUrl>; pub type ShapeOutside = generic::GenericShapeOutside<BasicShape, Image>; /// A computed basic shape. -pub type BasicShape = - generic::GenericBasicShape<Position, LengthPercentage, NonNegativeLengthPercentage, InsetRect>; +pub type BasicShape = generic::GenericBasicShape< + Angle, + Position, + LengthPercentage, + NonNegativeLengthPercentage, + InsetRect, +>; /// The computed value of `inset()`. pub type InsetRect = generic::GenericInsetRect<LengthPercentage, NonNegativeLengthPercentage>; @@ -35,3 +43,179 @@ pub type Ellipse = generic::Ellipse<Position, NonNegativeLengthPercentage>; /// The computed value of `ShapeRadius`. pub type ShapeRadius = generic::GenericShapeRadius<NonNegativeLengthPercentage>; + +/// The computed value of `shape()`. +pub type Shape = generic::Shape<Angle, LengthPercentage>; + +/// The computed value of `ShapeCommand`. +pub type ShapeCommand = generic::GenericShapeCommand<Angle, LengthPercentage>; + +/// The computed value of `PathOrShapeFunction`. +pub type PathOrShapeFunction = generic::GenericPathOrShapeFunction<Angle, LengthPercentage>; + +/// The computed value of `CoordinatePair`. +pub type CoordinatePair = generic::CoordinatePair<LengthPercentage>; + +/// Animate from `Shape` to `Path`, and vice versa. +macro_rules! animate_shape { + ( + $from:ident, + $to:ident, + $procedure:ident, + $from_as_shape:tt, + $to_as_shape:tt + ) => {{ + // Check fill-rule. + if $from.fill != $to.fill { + return Err(()); + } + + // Check the list of commands. (This is a specialized lists::by_computed_value::animate().) + let from_cmds = $from.commands(); + let to_cmds = $to.commands(); + if from_cmds.len() != to_cmds.len() { + return Err(()); + } + let commands = from_cmds + .iter() + .zip(to_cmds.iter()) + .map(|(from_cmd, to_cmd)| { + $from_as_shape(from_cmd).animate(&$to_as_shape(to_cmd), $procedure) + }) + .collect::<Result<Vec<ShapeCommand>, ()>>()?; + + Ok(Shape { + fill: $from.fill, + commands: commands.into(), + }) + }}; +} + +impl Animate for PathOrShapeFunction { + #[inline] + fn animate(&self, other: &Self, procedure: Procedure) -> Result<Self, ()> { + // Per spec, commands are "the same" if they use the same command keyword, and use the same + // <by-to> keyword. For curve and smooth, they also must have the same number of control + // points. Therefore, we don't have to do normalization here. (Note that we do + // normalization if we animate from path() to path(). See svg_path.rs for more details.) + // + // https://drafts.csswg.org/css-shapes-2/#interpolating-shape + match (self, other) { + (Self::Path(ref from), Self::Path(ref to)) => { + from.animate(to, procedure).map(Self::Path) + }, + (Self::Shape(ref from), Self::Shape(ref to)) => { + from.animate(to, procedure).map(Self::Shape) + }, + (Self::Shape(ref from), Self::Path(ref to)) => { + // Animate from shape() to path(). We convert each PathCommand into ShapeCommand, + // and return shape(). + animate_shape!( + from, + to, + procedure, + (|shape_cmd| shape_cmd), + (|path_cmd| ShapeCommand::from(path_cmd)) + ) + .map(Self::Shape) + }, + (Self::Path(ref from), Self::Shape(ref to)) => { + // Animate from path() to shape(). We convert each PathCommand into ShapeCommand, + // and return shape(). + animate_shape!( + from, + to, + procedure, + (|path_cmd| ShapeCommand::from(path_cmd)), + (|shape_cmd| shape_cmd) + ) + .map(Self::Shape) + }, + } + } +} + +impl From<&PathCommand> for ShapeCommand { + #[inline] + fn from(path: &PathCommand) -> Self { + use crate::values::computed::CSSPixelLength; + match path { + &PathCommand::Close => Self::Close, + &PathCommand::Move { by_to, ref point } => Self::Move { + by_to, + point: point.into(), + }, + &PathCommand::Line { by_to, ref point } => Self::Move { + by_to, + point: point.into(), + }, + &PathCommand::HLine { by_to, x } => Self::HLine { + by_to, + x: LengthPercentage::new_length(CSSPixelLength::new(x)), + }, + &PathCommand::VLine { by_to, y } => Self::VLine { + by_to, + y: LengthPercentage::new_length(CSSPixelLength::new(y)), + }, + &PathCommand::CubicCurve { + by_to, + ref point, + ref control1, + ref control2, + } => Self::CubicCurve { + by_to, + point: point.into(), + control1: control1.into(), + control2: control2.into(), + }, + &PathCommand::QuadCurve { + by_to, + ref point, + ref control1, + } => Self::QuadCurve { + by_to, + point: point.into(), + control1: control1.into(), + }, + &PathCommand::SmoothCubic { + by_to, + ref point, + ref control2, + } => Self::SmoothCubic { + by_to, + point: point.into(), + control2: control2.into(), + }, + &PathCommand::SmoothQuad { by_to, ref point } => Self::SmoothQuad { + by_to, + point: point.into(), + }, + &PathCommand::Arc { + by_to, + ref point, + ref radii, + arc_sweep, + arc_size, + rotate, + } => Self::Arc { + by_to, + point: point.into(), + radii: radii.into(), + arc_sweep, + arc_size, + rotate: Angle::from_degrees(rotate), + }, + } + } +} + +impl From<&CoordPair> for CoordinatePair { + #[inline] + fn from(p: &CoordPair) -> Self { + use crate::values::computed::CSSPixelLength; + Self::new( + LengthPercentage::new_length(CSSPixelLength::new(p.x)), + LengthPercentage::new_length(CSSPixelLength::new(p.y)), + ) + } +} diff --git a/servo/components/style/values/computed/box.rs b/servo/components/style/values/computed/box.rs index 62811d9851..0dea1c7ab9 100644 --- a/servo/components/style/values/computed/box.rs +++ b/servo/components/style/values/computed/box.rs @@ -383,6 +383,15 @@ impl Zoom { if self == Self::ONE { return value; } - self.value() * value + value * self.value() + } + + /// Returns the un-zoomed value. + #[inline] + pub fn unzoom(self, value: f32) -> f32 { + if self == Self::ONE { + return value; + } + value / self.value() } } diff --git a/servo/components/style/values/computed/font.rs b/servo/components/style/values/computed/font.rs index de0a5e372b..e492584f75 100644 --- a/servo/components/style/values/computed/font.rs +++ b/servo/components/style/values/computed/font.rs @@ -8,7 +8,7 @@ use crate::parser::{Parse, ParserContext}; use crate::values::animated::ToAnimatedValue; use crate::values::computed::{ Angle, Context, Integer, Length, NonNegativeLength, NonNegativeNumber, Number, Percentage, - ToComputedValue, + ToComputedValue, Zoom, }; use crate::values::generics::font::{ FeatureTagValue, FontSettings, TaggedFontValue, VariationValue, @@ -278,6 +278,16 @@ impl FontSize { self.used_size.0 } + /// Apply zoom to the font-size. This is usually done by ToComputedValue. + #[inline] + pub fn zoom(&self, zoom: Zoom) -> Self { + Self { + computed_size: NonNegative(Length::new(zoom.zoom(self.computed_size.0.px()))), + used_size: NonNegative(Length::new(zoom.zoom(self.used_size.0.px()))), + keyword_info: self.keyword_info, + } + } + #[inline] /// Get default value of font size. pub fn medium() -> Self { @@ -1359,7 +1369,7 @@ impl ToResolvedValue for LineHeight { context.style.get_font(), wm, Some(context.element_info.element), - )) + ).to_resolved_value(context)) } #[inline] diff --git a/servo/components/style/values/computed/length.rs b/servo/components/style/values/computed/length.rs index e75676a76d..881efed126 100644 --- a/servo/components/style/values/computed/length.rs +++ b/servo/components/style/values/computed/length.rs @@ -6,12 +6,13 @@ use super::{Context, Number, ToComputedValue}; use crate::values::animated::ToAnimatedValue; -use crate::values::computed::NonNegativeNumber; +use crate::values::computed::{NonNegativeNumber, Zoom}; use crate::values::generics::length as generics; use crate::values::generics::length::{ GenericLengthOrNumber, GenericLengthPercentageOrNormal, GenericMaxSize, GenericSize, }; use crate::values::generics::NonNegative; +use crate::values::resolved::{Context as ResolvedContext, ToResolvedValue}; use crate::values::specified::length::{AbsoluteLength, FontBaseSize, LineHeightBase}; use crate::values::{specified, CSSFloat}; use crate::Zero; @@ -227,12 +228,24 @@ impl Size { ToAnimatedValue, ToAnimatedZero, ToComputedValue, - ToResolvedValue, ToShmem, )] #[repr(C)] pub struct CSSPixelLength(CSSFloat); +impl ToResolvedValue for CSSPixelLength { + type ResolvedValue = Self; + + fn to_resolved_value(self, context: &ResolvedContext) -> Self::ResolvedValue { + Self(context.style.effective_zoom.unzoom(self.0)) + } + + #[inline] + fn from_resolved_value(value: Self::ResolvedValue) -> Self { + value + } +} + impl fmt::Debug for CSSPixelLength { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { self.0.fmt(f)?; @@ -271,6 +284,12 @@ impl CSSPixelLength { self.0 } + /// Zooms a particular length. + #[inline] + pub fn zoom(self, zoom: Zoom) -> Self { + Self::new(zoom.zoom(self.px())) + } + /// Return the length with app_unit i32 type. #[inline] pub fn to_i32_au(self) -> i32 { diff --git a/servo/components/style/values/computed/length_percentage.rs b/servo/components/style/values/computed/length_percentage.rs index 0dbd2de76d..c448025dd1 100644 --- a/servo/components/style/values/computed/length_percentage.rs +++ b/servo/components/style/values/computed/length_percentage.rs @@ -30,6 +30,7 @@ use crate::values::animated::{Animate, Procedure, ToAnimatedValue, ToAnimatedZer use crate::values::distance::{ComputeSquaredDistance, SquaredDistance}; use crate::values::generics::calc::{CalcUnits, PositivePercentageBasis}; use crate::values::generics::{calc, NonNegative}; +use crate::values::resolved::{Context as ResolvedContext, ToResolvedValue}; use crate::values::specified::length::{FontBaseSize, LineHeightBase}; use crate::values::{specified, CSSFloat}; use crate::{Zero, ZeroNoPercent}; @@ -164,6 +165,25 @@ impl MallocSizeOf for LengthPercentage { } } +impl ToResolvedValue for LengthPercentage { + type ResolvedValue = Self; + + fn to_resolved_value(self, context: &ResolvedContext) -> Self::ResolvedValue { + if context.style.effective_zoom.is_one() { + return self; + } + match self.unpack() { + Unpacked::Length(l) => Self::new_length(l.to_resolved_value(context)), + Unpacked::Percentage(..) | Unpacked::Calc(..) => self, + } + } + + #[inline] + fn from_resolved_value(value: Self::ResolvedValue) -> Self { + value + } +} + /// An unpacked `<length-percentage>` that borrows the `calc()` variant. #[derive(Clone, Debug, PartialEq, ToCss)] enum Unpacked<'a> { diff --git a/servo/components/style/values/computed/ratio.rs b/servo/components/style/values/computed/ratio.rs index ae8997cfc0..6964eec3e4 100644 --- a/servo/components/style/values/computed/ratio.rs +++ b/servo/components/style/values/computed/ratio.rs @@ -9,7 +9,7 @@ use crate::values::computed::NonNegativeNumber; use crate::values::distance::{ComputeSquaredDistance, SquaredDistance}; use crate::values::generics::ratio::Ratio as GenericRatio; use crate::{One, Zero}; -use std::cmp::{Ordering, PartialOrd}; +use std::cmp::Ordering; /// A computed <ratio> value. pub type Ratio = GenericRatio<NonNegativeNumber>; diff --git a/servo/components/style/values/generics/basic_shape.rs b/servo/components/style/values/generics/basic_shape.rs index 13d27995c1..ca7646fb13 100644 --- a/servo/components/style/values/generics/basic_shape.rs +++ b/servo/components/style/values/generics/basic_shape.rs @@ -10,7 +10,7 @@ use crate::values::distance::{ComputeSquaredDistance, SquaredDistance}; use crate::values::generics::border::GenericBorderRadius; use crate::values::generics::position::GenericPositionOrAuto; use crate::values::generics::rect::Rect; -use crate::values::specified::SVGPathData; +use crate::values::specified::svg_path::{PathCommand, SVGPathData}; use crate::Zero; use std::fmt::{self, Write}; use style_traits::{CssWriter, ToCss}; @@ -181,8 +181,13 @@ pub use self::GenericShapeOutside as ShapeOutside; ToShmem, )] #[repr(C, u8)] -pub enum GenericBasicShape<Position, LengthPercentage, NonNegativeLengthPercentage, BasicShapeRect> -{ +pub enum GenericBasicShape< + Angle, + Position, + LengthPercentage, + NonNegativeLengthPercentage, + BasicShapeRect, +> { /// The <basic-shape-rect>. Rect(BasicShapeRect), /// Defines a circle with a center and a radius. @@ -199,10 +204,11 @@ pub enum GenericBasicShape<Position, LengthPercentage, NonNegativeLengthPercenta ), /// Defines a polygon with pair arguments. Polygon(GenericPolygon<LengthPercentage>), - /// Defines a path with SVG path syntax. - Path(Path), - // TODO: Bug 1823463. Add shape(). - // https://drafts.csswg.org/css-shapes-2/#shape-function + /// Defines a path() or shape(). + PathOrShape( + #[animation(field_bound)] + #[css(field_bound)] + GenericPathOrShapeFunction<Angle, LengthPercentage>), } pub use self::GenericBasicShape as BasicShape; @@ -366,6 +372,30 @@ pub use self::GenericPolygon as Polygon; #[repr(C)] pub struct PolygonCoord<LengthPercentage>(pub LengthPercentage, pub LengthPercentage); +/// path() function or shape() function. +#[derive( + Clone, + ComputeSquaredDistance, + Debug, + Deserialize, + MallocSizeOf, + PartialEq, + Serialize, + SpecifiedValueInfo, + ToAnimatedValue, + ToComputedValue, + ToCss, + ToResolvedValue, + ToShmem, +)] +#[repr(C, u8)] +pub enum GenericPathOrShapeFunction<Angle, LengthPercentage> { + /// Defines a path with SVG path syntax. + Path(Path), + /// Defines a shape function, which is identical to path() but it uses the CSS syntax. + Shape(#[css(field_bound)] Shape<Angle, LengthPercentage>), +} + // https://drafts.csswg.org/css-shapes/#typedef-fill-rule // NOTE: Basic shapes spec says that these are the only two values, however // https://www.w3.org/TR/SVG/painting.html#FillRuleProperty @@ -397,9 +427,9 @@ pub enum FillRule { Evenodd, } -/// The path function defined in css-shape-2. +/// The path function. /// -/// https://drafts.csswg.org/css-shapes-2/#funcdef-path +/// https://drafts.csswg.org/css-shapes-1/#funcdef-basic-shape-path #[derive( Animate, Clone, @@ -426,6 +456,14 @@ pub struct Path { pub path: SVGPathData, } +impl Path { + /// Returns the slice of PathCommand. + #[inline] + pub fn commands(&self) -> &[PathCommand] { + self.path.commands() + } +} + impl<B, U> ToAnimatedZero for ClipPath<B, U> { fn to_animated_zero(&self) -> Result<Self, ()> { Err(()) @@ -565,3 +603,479 @@ impl Default for FillRule { fn is_default<T: Default + PartialEq>(fill: &T) -> bool { *fill == Default::default() } + +/// The shape function defined in css-shape-2. +/// shape() = shape(<fill-rule>? from <coordinate-pair>, <shape-command>#) +/// +/// https://drafts.csswg.org/css-shapes-2/#shape-function +#[derive( + Clone, + Debug, + Deserialize, + MallocSizeOf, + PartialEq, + Serialize, + SpecifiedValueInfo, + ToAnimatedValue, + ToComputedValue, + ToResolvedValue, + ToShmem, +)] +#[repr(C)] +pub struct Shape<Angle, LengthPercentage> { + /// The filling rule for this shape. + pub fill: FillRule, + /// The shape command data. Note that the starting point will be the first command in this + /// slice. + // Note: The first command is always GenericShapeCommand::Move. + pub commands: crate::OwnedSlice<GenericShapeCommand<Angle, LengthPercentage>>, +} + +impl<Angle, LengthPercentage> Shape<Angle, LengthPercentage> { + /// Returns the slice of GenericShapeCommand<..>. + #[inline] + pub fn commands(&self) -> &[GenericShapeCommand<Angle, LengthPercentage>] { + &self.commands + } +} + +impl<Angle, LengthPercentage> Animate for Shape<Angle, LengthPercentage> +where + Angle: Animate, + LengthPercentage: Animate, +{ + fn animate(&self, other: &Self, procedure: Procedure) -> Result<Self, ()> { + if self.fill != other.fill { + return Err(()); + } + let commands = + lists::by_computed_value::animate(&self.commands, &other.commands, procedure)?; + Ok(Self { + fill: self.fill, + commands, + }) + } +} + +impl<Angle, LengthPercentage> ComputeSquaredDistance for Shape<Angle, LengthPercentage> +where + Angle: ComputeSquaredDistance, + LengthPercentage: ComputeSquaredDistance, +{ + fn compute_squared_distance(&self, other: &Self) -> Result<SquaredDistance, ()> { + if self.fill != other.fill { + return Err(()); + } + lists::by_computed_value::squared_distance(&self.commands, &other.commands) + } +} + +impl<Angle, LengthPercentage> ToCss for Shape<Angle, LengthPercentage> +where + Angle: ToCss + Zero, + LengthPercentage: PartialEq + ToCss, +{ + fn to_css<W>(&self, dest: &mut CssWriter<W>) -> fmt::Result + where + W: Write, + { + use style_traits::values::SequenceWriter; + + // Per spec, we must have the first move command and at least one following command. + debug_assert!(self.commands.len() > 1); + + dest.write_str("shape(")?; + if !is_default(&self.fill) { + self.fill.to_css(dest)?; + dest.write_char(' ')?; + } + dest.write_str("from ")?; + match self.commands[0] { + ShapeCommand::Move { + by_to: _, + ref point, + } => point.to_css(dest)?, + _ => unreachable!("The first command must be move"), + } + dest.write_str(", ")?; + { + let mut writer = SequenceWriter::new(dest, ", "); + for command in self.commands.iter().skip(1) { + writer.item(command)?; + } + } + dest.write_char(')') + } +} + +/// This is a more general shape(path) command type, for both shape() and path(). +/// +/// https://www.w3.org/TR/SVG11/paths.html#PathData +/// https://drafts.csswg.org/css-shapes-2/#shape-function +#[derive( + Animate, + Clone, + ComputeSquaredDistance, + Copy, + Debug, + Deserialize, + MallocSizeOf, + PartialEq, + Serialize, + SpecifiedValueInfo, + ToAnimatedValue, + ToAnimatedZero, + ToComputedValue, + ToResolvedValue, + ToShmem, +)] +#[allow(missing_docs)] +#[repr(C, u8)] +pub enum GenericShapeCommand<Angle, LengthPercentage> { + /// The move command. + Move { + by_to: ByTo, + point: CoordinatePair<LengthPercentage>, + }, + /// The line command. + Line { + by_to: ByTo, + point: CoordinatePair<LengthPercentage>, + }, + /// The hline command. + HLine { by_to: ByTo, x: LengthPercentage }, + /// The vline command. + VLine { by_to: ByTo, y: LengthPercentage }, + /// The cubic Bézier curve command. + CubicCurve { + by_to: ByTo, + point: CoordinatePair<LengthPercentage>, + control1: CoordinatePair<LengthPercentage>, + control2: CoordinatePair<LengthPercentage>, + }, + /// The quadratic Bézier curve command. + QuadCurve { + by_to: ByTo, + point: CoordinatePair<LengthPercentage>, + control1: CoordinatePair<LengthPercentage>, + }, + /// The smooth command. + SmoothCubic { + by_to: ByTo, + point: CoordinatePair<LengthPercentage>, + control2: CoordinatePair<LengthPercentage>, + }, + /// The smooth quadratic Bézier curve command. + SmoothQuad { + by_to: ByTo, + point: CoordinatePair<LengthPercentage>, + }, + /// The arc command. + Arc { + by_to: ByTo, + point: CoordinatePair<LengthPercentage>, + radii: CoordinatePair<LengthPercentage>, + arc_sweep: ArcSweep, + arc_size: ArcSize, + rotate: Angle, + }, + /// The closepath command. + Close, +} + +pub use self::GenericShapeCommand as ShapeCommand; + +impl<Angle, LengthPercentage> ToCss for ShapeCommand<Angle, LengthPercentage> +where + Angle: ToCss + Zero, + LengthPercentage: PartialEq + ToCss, +{ + fn to_css<W>(&self, dest: &mut CssWriter<W>) -> fmt::Result + where + W: fmt::Write, + { + use self::ShapeCommand::*; + match *self { + Move { by_to, ref point } => { + dest.write_str("move ")?; + by_to.to_css(dest)?; + dest.write_char(' ')?; + point.to_css(dest) + }, + Line { by_to, ref point } => { + dest.write_str("line ")?; + by_to.to_css(dest)?; + dest.write_char(' ')?; + point.to_css(dest) + }, + HLine { by_to, ref x } => { + dest.write_str("hline ")?; + by_to.to_css(dest)?; + dest.write_char(' ')?; + x.to_css(dest) + }, + VLine { by_to, ref y } => { + dest.write_str("vline ")?; + by_to.to_css(dest)?; + dest.write_char(' ')?; + y.to_css(dest) + }, + CubicCurve { + by_to, + ref point, + ref control1, + ref control2, + } => { + dest.write_str("curve ")?; + by_to.to_css(dest)?; + dest.write_char(' ')?; + point.to_css(dest)?; + dest.write_str(" via ")?; + control1.to_css(dest)?; + dest.write_char(' ')?; + control2.to_css(dest) + }, + QuadCurve { + by_to, + ref point, + ref control1, + } => { + dest.write_str("curve ")?; + by_to.to_css(dest)?; + dest.write_char(' ')?; + point.to_css(dest)?; + dest.write_str(" via ")?; + control1.to_css(dest) + }, + SmoothCubic { + by_to, + ref point, + ref control2, + } => { + dest.write_str("smooth ")?; + by_to.to_css(dest)?; + dest.write_char(' ')?; + point.to_css(dest)?; + dest.write_str(" via ")?; + control2.to_css(dest) + }, + SmoothQuad { by_to, ref point } => { + dest.write_str("smooth ")?; + by_to.to_css(dest)?; + dest.write_char(' ')?; + point.to_css(dest) + }, + Arc { + by_to, + ref point, + ref radii, + arc_sweep, + arc_size, + ref rotate, + } => { + dest.write_str("arc ")?; + by_to.to_css(dest)?; + dest.write_char(' ')?; + point.to_css(dest)?; + dest.write_str(" of ")?; + radii.x.to_css(dest)?; + if radii.x != radii.y { + dest.write_char(' ')?; + radii.y.to_css(dest)?; + } + + if matches!(arc_sweep, ArcSweep::Cw) { + dest.write_str(" cw")?; + } + + if matches!(arc_size, ArcSize::Large) { + dest.write_str(" large")?; + } + + if !rotate.is_zero() { + dest.write_str(" rotate ")?; + rotate.to_css(dest)?; + } + Ok(()) + }, + Close => dest.write_str("close"), + } + } +} + +/// This indicates the command is absolute or relative. +/// https://drafts.csswg.org/css-shapes-2/#typedef-shape-by-to +#[derive( + Animate, + Clone, + ComputeSquaredDistance, + Copy, + Debug, + Deserialize, + MallocSizeOf, + Parse, + PartialEq, + Serialize, + SpecifiedValueInfo, + ToAnimatedValue, + ToAnimatedZero, + ToComputedValue, + ToCss, + ToResolvedValue, + ToShmem, +)] +#[repr(u8)] +pub enum ByTo { + /// This indicates that the <coordinate-pair>s are relative to the command’s starting point. + By, + /// This relative to the top-left corner of the reference box. + To, +} + +impl ByTo { + /// Return true if it is absolute, i.e. it is To. + #[inline] + pub fn is_abs(&self) -> bool { + matches!(self, ByTo::To) + } + + /// Create ByTo based on the flag if it is absolute. + #[inline] + pub fn new(is_abs: bool) -> Self { + if is_abs { + Self::To + } else { + Self::By + } + } +} + +/// Defines a pair of coordinates, representing a rightward and downward offset, respectively, from +/// a specified reference point. Percentages are resolved against the width or height, +/// respectively, of the reference box. +/// https://drafts.csswg.org/css-shapes-2/#typedef-shape-coordinate-pair +#[allow(missing_docs)] +#[derive( + AddAssign, + Animate, + Clone, + ComputeSquaredDistance, + Copy, + Debug, + Deserialize, + MallocSizeOf, + PartialEq, + Serialize, + SpecifiedValueInfo, + ToAnimatedValue, + ToAnimatedZero, + ToComputedValue, + ToCss, + ToResolvedValue, + ToShmem, +)] +#[repr(C)] +pub struct CoordinatePair<LengthPercentage> { + pub x: LengthPercentage, + pub y: LengthPercentage, +} + +impl<LengthPercentage> CoordinatePair<LengthPercentage> { + /// Create a CoordinatePair. + #[inline] + pub fn new(x: LengthPercentage, y: LengthPercentage) -> Self { + Self { x, y } + } +} + +/// This indicates that the arc that is traced around the ellipse clockwise or counter-clockwise +/// from the center. +/// https://drafts.csswg.org/css-shapes-2/#typedef-shape-arc-sweep +#[derive( + Clone, + Copy, + Debug, + Deserialize, + FromPrimitive, + MallocSizeOf, + Parse, + PartialEq, + Serialize, + SpecifiedValueInfo, + ToAnimatedValue, + ToAnimatedZero, + ToComputedValue, + ToCss, + ToResolvedValue, + ToShmem, +)] +#[repr(u8)] +pub enum ArcSweep { + /// Counter-clockwise. The default value. (This also represents 0 in the svg path.) + Ccw = 0, + /// Clockwise. (This also represents 1 in the svg path.) + Cw = 1, +} + +impl Animate for ArcSweep { + fn animate(&self, other: &Self, procedure: Procedure) -> Result<Self, ()> { + use num_traits::FromPrimitive; + // If an arc command has different <arc-sweep> between its starting and ending list, then + // the interpolated result uses cw for any progress value between 0 and 1. + (*self as i32) + .animate(&(*other as i32), procedure) + .map(|v| ArcSweep::from_u8((v > 0) as u8).unwrap_or(ArcSweep::Ccw)) + } +} + +impl ComputeSquaredDistance for ArcSweep { + fn compute_squared_distance(&self, other: &Self) -> Result<SquaredDistance, ()> { + (*self as i32).compute_squared_distance(&(*other as i32)) + } +} + +/// This indicates that the larger or smaller, respectively, of the two possible arcs must be +/// chosen. +/// https://drafts.csswg.org/css-shapes-2/#typedef-shape-arc-size +#[derive( + Clone, + Copy, + Debug, + Deserialize, + FromPrimitive, + MallocSizeOf, + Parse, + PartialEq, + Serialize, + SpecifiedValueInfo, + ToAnimatedValue, + ToAnimatedZero, + ToComputedValue, + ToCss, + ToResolvedValue, + ToShmem, +)] +#[repr(u8)] +pub enum ArcSize { + /// Choose the small one. The default value. (This also represents 0 in the svg path.) + Small = 0, + /// Choose the large one. (This also represents 1 in the svg path.) + Large = 1, +} + +impl Animate for ArcSize { + fn animate(&self, other: &Self, procedure: Procedure) -> Result<Self, ()> { + use num_traits::FromPrimitive; + // If it has different <arc-size> keywords, then the interpolated result uses large for any + // progress value between 0 and 1. + (*self as i32) + .animate(&(*other as i32), procedure) + .map(|v| ArcSize::from_u8((v > 0) as u8).unwrap_or(ArcSize::Small)) + } +} + +impl ComputeSquaredDistance for ArcSize { + fn compute_squared_distance(&self, other: &Self) -> Result<SquaredDistance, ()> { + (*self as i32).compute_squared_distance(&(*other as i32)) + } +} diff --git a/servo/components/style/values/generics/counters.rs b/servo/components/style/values/generics/counters.rs index 1d4518c57b..3f23c74b33 100644 --- a/servo/components/style/values/generics/counters.rs +++ b/servo/components/style/values/generics/counters.rs @@ -4,11 +4,10 @@ //! Generic types for counters-related CSS values. -#[cfg(feature = "servo-layout-2013")] +#[cfg(feature = "servo")] use crate::computed_values::list_style_type::T as ListStyleType; #[cfg(feature = "gecko")] use crate::values::generics::CounterStyle; -#[cfg(any(feature = "gecko", feature = "servo-layout-2020"))] use crate::values::specified::Attr; use crate::values::CustomIdent; use std::fmt::{self, Write}; @@ -186,13 +185,13 @@ pub struct GenericCounters<I>( ); pub use self::GenericCounters as Counters; -#[cfg(feature = "servo-layout-2013")] +#[cfg(feature = "servo")] type CounterStyleType = ListStyleType; #[cfg(feature = "gecko")] type CounterStyleType = CounterStyle; -#[cfg(feature = "servo-layout-2013")] +#[cfg(feature = "servo")] #[inline] fn is_decimal(counter_type: &CounterStyleType) -> bool { *counter_type == ListStyleType::Decimal @@ -254,11 +253,9 @@ pub enum GenericContentItem<I> { /// Literal string content. String(crate::OwnedStr), /// `counter(name, style)`. - #[cfg(any(feature = "gecko", feature = "servo-layout-2013"))] #[css(comma, function)] Counter(CustomIdent, #[css(skip_if = "is_decimal")] CounterStyleType), /// `counters(name, separator, style)`. - #[cfg(any(feature = "gecko", feature = "servo-layout-2013"))] #[css(comma, function)] Counters( CustomIdent, @@ -266,16 +263,12 @@ pub enum GenericContentItem<I> { #[css(skip_if = "is_decimal")] CounterStyleType, ), /// `open-quote`. - #[cfg(any(feature = "gecko", feature = "servo-layout-2013"))] OpenQuote, /// `close-quote`. - #[cfg(any(feature = "gecko", feature = "servo-layout-2013"))] CloseQuote, /// `no-open-quote`. - #[cfg(any(feature = "gecko", feature = "servo-layout-2013"))] NoOpenQuote, /// `no-close-quote`. - #[cfg(any(feature = "gecko", feature = "servo-layout-2013"))] NoCloseQuote, /// `-moz-alt-content`. #[cfg(feature = "gecko")] @@ -286,7 +279,6 @@ pub enum GenericContentItem<I> { #[cfg(feature = "gecko")] MozLabelContent, /// `attr([namespace? `|`]? ident)` - #[cfg(any(feature = "gecko", feature = "servo-layout-2020"))] Attr(Attr), /// image-set(url) | url(url) Image(I), diff --git a/servo/components/style/values/generics/image.rs b/servo/components/style/values/generics/image.rs index 6fc0870e15..ca1c716052 100644 --- a/servo/components/style/values/generics/image.rs +++ b/servo/components/style/values/generics/image.rs @@ -41,7 +41,7 @@ pub enum GenericImage<G, ImageUrl, Color, Percentage, Resolution> { /// A paint worklet image. /// <https://drafts.css-houdini.org/css-paint-api/> - #[cfg(feature = "servo-layout-2013")] + #[cfg(feature = "servo")] PaintWorklet(PaintWorklet), /// A `<cross-fade()>` image. Storing this directly inside of @@ -416,7 +416,7 @@ where Image::None => dest.write_str("none"), Image::Url(ref url) => url.to_css(dest), Image::Gradient(ref gradient) => gradient.to_css(dest), - #[cfg(feature = "servo-layout-2013")] + #[cfg(feature = "servo")] Image::PaintWorklet(ref paint_worklet) => paint_worklet.to_css(dest), #[cfg(feature = "gecko")] Image::Element(ref selector) => { diff --git a/servo/components/style/values/generics/transform.rs b/servo/components/style/values/generics/transform.rs index 3a65c460a7..4d70e4465c 100644 --- a/servo/components/style/values/generics/transform.rs +++ b/servo/components/style/values/generics/transform.rs @@ -11,7 +11,6 @@ use crate::values::specified::length::Length as SpecifiedLength; use crate::values::specified::length::LengthPercentage as SpecifiedLengthPercentage; use crate::values::{computed, CSSFloat}; use crate::{Zero, ZeroNoPercent}; -use euclid; use euclid::default::{Rect, Transform3D}; use std::fmt::{self, Write}; use style_traits::{CssWriter, ToCss}; diff --git a/servo/components/style/values/resolved/mod.rs b/servo/components/style/values/resolved/mod.rs index 675f3cca68..d830474fe6 100644 --- a/servo/components/style/values/resolved/mod.rs +++ b/servo/components/style/values/resolved/mod.rs @@ -95,7 +95,6 @@ trivial_to_resolved_value!(computed::url::ComputedImageUrl); trivial_to_resolved_value!(crate::Namespace); #[cfg(feature = "servo")] trivial_to_resolved_value!(crate::Prefix); -trivial_to_resolved_value!(computed::LengthPercentage); trivial_to_resolved_value!(style_traits::values::specified::AllowedNumericType); trivial_to_resolved_value!(computed::TimingFunction); diff --git a/servo/components/style/values/specified/animation.rs b/servo/components/style/values/specified/animation.rs index 5a1f5003f3..552521711c 100644 --- a/servo/components/style/values/specified/animation.rs +++ b/servo/components/style/values/specified/animation.rs @@ -165,6 +165,12 @@ impl AnimationIterationCount { pub fn one() -> Self { Self::Number(NonNegativeNumber::new(1.0)) } + + /// Returns true if it's `1.0`. + #[inline] + pub fn is_one(&self) -> bool { + *self == Self::one() + } } /// A value for the `animation-name` property. @@ -230,6 +236,17 @@ pub enum AnimationDirection { AlternateReverse, } +impl AnimationDirection { + /// Returns true if the name matches any animation-direction keyword. + #[inline] + pub fn match_keywords(name: &AnimationName) -> bool { + if let Some(name) = name.as_atom() { + return name.with_str(|n| Self::from_ident(n).is_ok()); + } + false + } +} + /// https://drafts.csswg.org/css-animations/#animation-play-state #[derive(Copy, Clone, Debug, MallocSizeOf, Parse, PartialEq, SpecifiedValueInfo, ToComputedValue, ToCss, ToResolvedValue, ToShmem)] #[repr(u8)] @@ -239,6 +256,17 @@ pub enum AnimationPlayState { Paused, } +impl AnimationPlayState { + /// Returns true if the name matches any animation-play-state keyword. + #[inline] + pub fn match_keywords(name: &AnimationName) -> bool { + if let Some(name) = name.as_atom() { + return name.with_str(|n| Self::from_ident(n).is_ok()); + } + false + } +} + /// https://drafts.csswg.org/css-animations/#propdef-animation-fill-mode #[derive(Copy, Clone, Debug, MallocSizeOf, Parse, PartialEq, SpecifiedValueInfo, ToComputedValue, ToCss, ToResolvedValue, ToShmem)] #[repr(u8)] @@ -250,6 +278,18 @@ pub enum AnimationFillMode { Both, } +impl AnimationFillMode { + /// Returns true if the name matches any animation-fill-mode keyword. + /// Note: animation-name:none is its initial value, so we don't have to match none here. + #[inline] + pub fn match_keywords(name: &AnimationName) -> bool { + if let Some(atom) = name.as_atom() { + return !name.is_none() && atom.with_str(|n| Self::from_ident(n).is_ok()); + } + false + } +} + /// https://drafts.csswg.org/css-animations-2/#animation-composition #[derive(Copy, Clone, Debug, MallocSizeOf, Parse, PartialEq, SpecifiedValueInfo, ToComputedValue, ToCss, ToResolvedValue, ToShmem)] #[repr(u8)] diff --git a/servo/components/style/values/specified/basic_shape.rs b/servo/components/style/values/specified/basic_shape.rs index 526296b735..8ed32c40c5 100644 --- a/servo/components/style/values/specified/basic_shape.rs +++ b/servo/components/style/values/specified/basic_shape.rs @@ -14,6 +14,7 @@ use crate::values::generics::basic_shape as generic; use crate::values::generics::basic_shape::{Path, PolygonCoord}; use crate::values::generics::position::{GenericPosition, GenericPositionOrAuto}; use crate::values::generics::rect::Rect; +use crate::values::specified::angle::Angle; use crate::values::specified::border::BorderRadius; use crate::values::specified::image::Image; use crate::values::specified::length::LengthPercentageOrAuto; @@ -40,6 +41,7 @@ pub type ShapePosition = GenericPosition<LengthPercentage, LengthPercentage>; /// A specified basic shape. pub type BasicShape = generic::GenericBasicShape< + Angle, ShapePosition, LengthPercentage, NonNegativeLengthPercentage, @@ -61,6 +63,12 @@ pub type ShapeRadius = generic::ShapeRadius<NonNegativeLengthPercentage>; /// The specified value of `Polygon`. pub type Polygon = generic::GenericPolygon<LengthPercentage>; +/// The specified value of `PathOrShapeFunction`. +pub type PathOrShapeFunction = generic::GenericPathOrShapeFunction<Angle, LengthPercentage>; + +/// The specified value of `ShapeCommand`. +pub type ShapeCommand = generic::GenericShapeCommand<Angle, LengthPercentage>; + /// The specified value of `xywh()`. /// Defines a rectangle via offsets from the top and left edge of the reference box, and a /// specified width and height. @@ -168,8 +176,8 @@ bitflags! { const POLYGON = 1 << 5; /// path(). const PATH = 1 << 6; - // TODO: Bug 1823463. Add shape(). - // const SHAPE = 1 << 7; + /// shape(). + const SHAPE = 1 << 7; /// All flags. const ALL = @@ -179,7 +187,8 @@ bitflags! { Self::CIRCLE.bits() | Self::ELLIPSE.bits() | Self::POLYGON.bits() | - Self::PATH.bits(); + Self::PATH.bits() | + Self::SHAPE.bits(); /// For shape-outside. const SHAPE_OUTSIDE = @@ -329,7 +338,17 @@ impl BasicShape { .map(BasicShape::Polygon) }, "path" if flags.contains(AllowedBasicShapes::PATH) => { - Path::parse_function_arguments(i, shape_type).map(BasicShape::Path) + Path::parse_function_arguments(i, shape_type) + .map(PathOrShapeFunction::Path) + .map(BasicShape::PathOrShape) + }, + "shape" + if flags.contains(AllowedBasicShapes::SHAPE) + && static_prefs::pref!("layout.css.basic-shape-shape.enabled") => + { + generic::Shape::parse_function_arguments(context, i, shape_type) + .map(PathOrShapeFunction::Shape) + .map(BasicShape::PathOrShape) }, _ => Err(location .new_custom_error(StyleParseErrorKind::UnexpectedFunction(function.clone()))), @@ -490,7 +509,11 @@ impl Ellipse { } } -fn parse_fill_rule<'i, 't>(input: &mut Parser<'i, 't>, shape_type: ShapeType) -> FillRule { +fn parse_fill_rule<'i, 't>( + input: &mut Parser<'i, 't>, + shape_type: ShapeType, + expect_comma: bool, +) -> FillRule { match shape_type { // Per [1] and [2], we ignore `<fill-rule>` for outline shapes, so always use a default // value. @@ -508,7 +531,9 @@ fn parse_fill_rule<'i, 't>(input: &mut Parser<'i, 't>, shape_type: ShapeType) -> ShapeType::Filled => input .try_parse(|i| -> Result<_, ParseError> { let fill = FillRule::parse(i)?; - i.expect_comma()?; + if expect_comma { + i.expect_comma()?; + } Ok(fill) }) .unwrap_or_default(), @@ -532,7 +557,7 @@ impl Polygon { input: &mut Parser<'i, 't>, shape_type: ShapeType, ) -> Result<Self, ParseError<'i>> { - let fill = parse_fill_rule(input, shape_type); + let fill = parse_fill_rule(input, shape_type, true /* has comma */); let coordinates = input .parse_comma_separated(|i| { Ok(PolygonCoord( @@ -554,7 +579,7 @@ impl Path { ) -> Result<Self, ParseError<'i>> { use crate::values::specified::svg_path::AllowEmpty; - let fill = parse_fill_rule(input, shape_type); + let fill = parse_fill_rule(input, shape_type, true /* has comma */); let path = SVGPathData::parse(input, AllowEmpty::No)?; Ok(Path { fill, path }) } @@ -717,3 +742,168 @@ impl ToComputedValue for BasicShapeRect { Self::Inset(ToComputedValue::from_computed_value(computed)) } } + +impl generic::Shape<Angle, LengthPercentage> { + /// Parse the inner arguments of a `shape` function. + /// shape() = shape(<fill-rule>? from <coordinate-pair>, <shape-command>#) + fn parse_function_arguments<'i, 't>( + context: &ParserContext, + input: &mut Parser<'i, 't>, + shape_type: ShapeType, + ) -> Result<Self, ParseError<'i>> { + let fill = parse_fill_rule(input, shape_type, false /* no following comma */); + + let mut first = true; + let commands = input.parse_comma_separated(|i| { + if first { + first = false; + + // The starting point for the first shape-command. It adds an initial absolute + // moveto to the list of path data commands, with the <coordinate-pair> measured + // from the top-left corner of the reference + i.expect_ident_matching("from")?; + Ok(ShapeCommand::Move { + by_to: generic::ByTo::To, + point: generic::CoordinatePair::parse(context, i)?, + }) + } else { + // The further path data commands. + ShapeCommand::parse(context, i) + } + })?; + + // We must have one starting point and at least one following <shape-command>. + if commands.len() < 2 { + return Err(input.new_custom_error(StyleParseErrorKind::UnspecifiedError)); + } + + Ok(Self { + fill, + commands: commands.into(), + }) + } +} + +impl Parse for ShapeCommand { + fn parse<'i, 't>( + context: &ParserContext, + input: &mut Parser<'i, 't>, + ) -> Result<Self, ParseError<'i>> { + use crate::values::generics::basic_shape::{ArcSize, ArcSweep, ByTo, CoordinatePair}; + + // <shape-command> = <move-command> | <line-command> | <hv-line-command> | + // <curve-command> | <smooth-command> | <arc-command> | close + Ok(try_match_ident_ignore_ascii_case! { input, + "close" => Self::Close, + "move" => { + let by_to = ByTo::parse(input)?; + let point = CoordinatePair::parse(context, input)?; + Self::Move { by_to, point } + }, + "line" => { + let by_to = ByTo::parse(input)?; + let point = CoordinatePair::parse(context, input)?; + Self::Line { by_to, point } + }, + "hline" => { + let by_to = ByTo::parse(input)?; + let x = LengthPercentage::parse(context, input)?; + Self::HLine { by_to, x } + }, + "vline" => { + let by_to = ByTo::parse(input)?; + let y = LengthPercentage::parse(context, input)?; + Self::VLine { by_to, y } + }, + "curve" => { + let by_to = ByTo::parse(input)?; + let point = CoordinatePair::parse(context, input)?; + input.expect_ident_matching("via")?; + let control1 = CoordinatePair::parse(context, input)?; + match input.try_parse(|i| CoordinatePair::parse(context, i)) { + Ok(control2) => Self::CubicCurve { + by_to, + point, + control1, + control2, + }, + Err(_) => Self::QuadCurve { + by_to, + point, + control1, + }, + } + }, + "smooth" => { + let by_to = ByTo::parse(input)?; + let point = CoordinatePair::parse(context, input)?; + if input.try_parse(|i| i.expect_ident_matching("via")).is_ok() { + let control2 = CoordinatePair::parse(context, input)?; + Self::SmoothCubic { + by_to, + point, + control2, + } + } else { + Self::SmoothQuad { by_to, point } + } + }, + "arc" => { + let by_to = ByTo::parse(input)?; + let point = CoordinatePair::parse(context, input)?; + input.expect_ident_matching("of")?; + let rx = LengthPercentage::parse(context, input)?; + let ry = input + .try_parse(|i| LengthPercentage::parse(context, i)) + .unwrap_or(rx.clone()); + let radii = CoordinatePair::new(rx, ry); + + // [<arc-sweep> || <arc-size> || rotate <angle>]? + let mut arc_sweep = None; + let mut arc_size = None; + let mut rotate = None; + loop { + if arc_sweep.is_none() { + arc_sweep = input.try_parse(ArcSweep::parse).ok(); + } + + if arc_size.is_none() { + arc_size = input.try_parse(ArcSize::parse).ok(); + if arc_size.is_some() { + continue; + } + } + + if rotate.is_none() + && input + .try_parse(|i| i.expect_ident_matching("rotate")) + .is_ok() + { + rotate = Some(Angle::parse(context, input)?); + continue; + } + break; + } + Self::Arc { + by_to, + point, + radii, + arc_sweep: arc_sweep.unwrap_or(ArcSweep::Ccw), + arc_size: arc_size.unwrap_or(ArcSize::Small), + rotate: rotate.unwrap_or(Angle::zero()), + } + }, + }) + } +} + +impl Parse for generic::CoordinatePair<LengthPercentage> { + fn parse<'i, 't>( + context: &ParserContext, + input: &mut Parser<'i, 't>, + ) -> Result<Self, ParseError<'i>> { + let x = LengthPercentage::parse(context, input)?; + let y = LengthPercentage::parse(context, input)?; + Ok(Self::new(x, y)) + } +} diff --git a/servo/components/style/values/specified/box.rs b/servo/components/style/values/specified/box.rs index 8414591c2b..ee50227504 100644 --- a/servo/components/style/values/specified/box.rs +++ b/servo/components/style/values/specified/box.rs @@ -19,12 +19,12 @@ use std::fmt::{self, Write}; use style_traits::{CssWriter, KeywordsCollectFn, ParseError}; use style_traits::{SpecifiedValueInfo, StyleParseErrorKind, ToCss}; -#[cfg(not(feature = "servo-layout-2020"))] +#[cfg(not(feature = "servo"))] fn flexbox_enabled() -> bool { true } -#[cfg(feature = "servo-layout-2020")] +#[cfg(feature = "servo")] fn flexbox_enabled() -> bool { servo_config::prefs::pref_map() .get("layout.flexbox.enabled") @@ -42,9 +42,7 @@ pub enum DisplayOutside { None = 0, Inline, Block, - #[cfg(any(feature = "servo-layout-2013", feature = "gecko"))] TableCaption, - #[cfg(any(feature = "servo-layout-2013", feature = "gecko"))] InternalTable, #[cfg(feature = "gecko")] InternalRuby, @@ -55,28 +53,19 @@ pub enum DisplayOutside { #[repr(u8)] pub enum DisplayInside { None = 0, - #[cfg(any(feature = "servo-layout-2020", feature = "gecko"))] Contents, Flow, FlowRoot, Flex, #[cfg(feature = "gecko")] Grid, - #[cfg(any(feature = "servo-layout-2013", feature = "gecko"))] Table, - #[cfg(any(feature = "servo-layout-2013", feature = "gecko"))] TableRowGroup, - #[cfg(any(feature = "servo-layout-2013", feature = "gecko"))] TableColumn, - #[cfg(any(feature = "servo-layout-2013", feature = "gecko"))] TableColumnGroup, - #[cfg(any(feature = "servo-layout-2013", feature = "gecko"))] TableHeaderGroup, - #[cfg(any(feature = "servo-layout-2013", feature = "gecko"))] TableFooterGroup, - #[cfg(any(feature = "servo-layout-2013", feature = "gecko"))] TableRow, - #[cfg(any(feature = "servo-layout-2013", feature = "gecko"))] TableCell, #[cfg(feature = "gecko")] Ruby, @@ -145,7 +134,6 @@ impl Display { /// ::new() inlined so cbindgen can use it pub const None: Self = Self(((DisplayOutside::None as u16) << Self::OUTSIDE_SHIFT) | DisplayInside::None as u16); - #[cfg(any(feature = "servo-layout-2020", feature = "gecko"))] pub const Contents: Self = Self( ((DisplayOutside::None as u16) << Self::OUTSIDE_SHIFT) | DisplayInside::Contents as u16, ); @@ -170,14 +158,11 @@ impl Display { #[cfg(feature = "gecko")] pub const InlineGrid: Self = Self(((DisplayOutside::Inline as u16) << Self::OUTSIDE_SHIFT) | DisplayInside::Grid as u16); - #[cfg(any(feature = "servo-layout-2013", feature = "gecko"))] pub const Table: Self = Self(((DisplayOutside::Block as u16) << Self::OUTSIDE_SHIFT) | DisplayInside::Table as u16); - #[cfg(any(feature = "servo-layout-2013", feature = "gecko"))] pub const InlineTable: Self = Self( ((DisplayOutside::Inline as u16) << Self::OUTSIDE_SHIFT) | DisplayInside::Table as u16, ); - #[cfg(any(feature = "servo-layout-2013", feature = "gecko"))] pub const TableCaption: Self = Self( ((DisplayOutside::TableCaption as u16) << Self::OUTSIDE_SHIFT) | DisplayInside::Flow as u16, ); @@ -195,37 +180,30 @@ impl Display { // Internal table boxes. - #[cfg(any(feature = "servo-layout-2013", feature = "gecko"))] pub const TableRowGroup: Self = Self( ((DisplayOutside::InternalTable as u16) << Self::OUTSIDE_SHIFT) | DisplayInside::TableRowGroup as u16, ); - #[cfg(any(feature = "servo-layout-2013", feature = "gecko"))] pub const TableHeaderGroup: Self = Self( ((DisplayOutside::InternalTable as u16) << Self::OUTSIDE_SHIFT) | DisplayInside::TableHeaderGroup as u16, ); - #[cfg(any(feature = "servo-layout-2013", feature = "gecko"))] pub const TableFooterGroup: Self = Self( ((DisplayOutside::InternalTable as u16) << Self::OUTSIDE_SHIFT) | DisplayInside::TableFooterGroup as u16, ); - #[cfg(any(feature = "servo-layout-2013", feature = "gecko"))] pub const TableColumn: Self = Self( ((DisplayOutside::InternalTable as u16) << Self::OUTSIDE_SHIFT) | DisplayInside::TableColumn as u16, ); - #[cfg(any(feature = "servo-layout-2013", feature = "gecko"))] pub const TableColumnGroup: Self = Self( ((DisplayOutside::InternalTable as u16) << Self::OUTSIDE_SHIFT) | DisplayInside::TableColumnGroup as u16, ); - #[cfg(any(feature = "servo-layout-2013", feature = "gecko"))] pub const TableRow: Self = Self( ((DisplayOutside::InternalTable as u16) << Self::OUTSIDE_SHIFT) | DisplayInside::TableRow as u16, ); - #[cfg(any(feature = "servo-layout-2013", feature = "gecko"))] pub const TableCell: Self = Self( ((DisplayOutside::InternalTable as u16) << Self::OUTSIDE_SHIFT) | DisplayInside::TableCell as u16, @@ -336,7 +314,6 @@ impl Display { pub fn is_atomic_inline_level(&self) -> bool { match *self { Display::InlineBlock | Display::InlineFlex => true, - #[cfg(any(feature = "servo-layout-2013"))] Display::InlineTable => true, _ => false, } @@ -373,7 +350,6 @@ impl Display { /// /// Also used for :root style adjustments. pub fn equivalent_block_display(&self, _is_root_element: bool) -> Self { - #[cfg(any(feature = "servo-layout-2020", feature = "gecko"))] { // Special handling for `contents` and `list-item`s on the root element. if _is_root_element && (self.is_contents() || self.is_list_item()) { @@ -392,7 +368,6 @@ impl Display { Display::from3(DisplayOutside::Block, inside, self.is_list_item()) }, DisplayOutside::Block | DisplayOutside::None => *self, - #[cfg(any(feature = "servo-layout-2013", feature = "gecko"))] _ => Display::Block, } } @@ -419,7 +394,6 @@ impl Display { #[inline] pub fn is_contents(&self) -> bool { match *self { - #[cfg(any(feature = "servo-layout-2020", feature = "gecko"))] Display::Contents => true, _ => false, } @@ -444,30 +418,20 @@ impl DisplayKeyword { use self::DisplayKeyword::*; Ok(try_match_ident_ignore_ascii_case! { input, "none" => Full(Display::None), - #[cfg(any(feature = "servo-layout-2020", feature = "gecko"))] "contents" => Full(Display::Contents), "inline-block" => Full(Display::InlineBlock), - #[cfg(any(feature = "servo-layout-2013", feature = "gecko"))] "inline-table" => Full(Display::InlineTable), "-webkit-flex" if flexbox_enabled() => Full(Display::Flex), "inline-flex" | "-webkit-inline-flex" if flexbox_enabled() => Full(Display::InlineFlex), #[cfg(feature = "gecko")] "inline-grid" => Full(Display::InlineGrid), - #[cfg(any(feature = "servo-layout-2013", feature = "gecko"))] "table-caption" => Full(Display::TableCaption), - #[cfg(any(feature = "servo-layout-2013", feature = "gecko"))] "table-row-group" => Full(Display::TableRowGroup), - #[cfg(any(feature = "servo-layout-2013", feature = "gecko"))] "table-header-group" => Full(Display::TableHeaderGroup), - #[cfg(any(feature = "servo-layout-2013", feature = "gecko"))] "table-footer-group" => Full(Display::TableFooterGroup), - #[cfg(any(feature = "servo-layout-2013", feature = "gecko"))] "table-column" => Full(Display::TableColumn), - #[cfg(any(feature = "servo-layout-2013", feature = "gecko"))] "table-column-group" => Full(Display::TableColumnGroup), - #[cfg(any(feature = "servo-layout-2013", feature = "gecko"))] "table-row" => Full(Display::TableRow), - #[cfg(any(feature = "servo-layout-2013", feature = "gecko"))] "table-cell" => Full(Display::TableCell), #[cfg(feature = "gecko")] "ruby-base" => Full(Display::RubyBase), @@ -493,9 +457,7 @@ impl DisplayKeyword { /// https://drafts.csswg.org/css-display/#typedef-display-inside "flow" => Inside(DisplayInside::Flow), "flex" if flexbox_enabled() => Inside(DisplayInside::Flex), - #[cfg(any(feature = "servo-layout-2020", feature = "gecko"))] "flow-root" => Inside(DisplayInside::FlowRoot), - #[cfg(any(feature = "servo-layout-2013", feature = "gecko"))] "table" => Inside(DisplayInside::Table), #[cfg(feature = "gecko")] "grid" => Inside(DisplayInside::Grid), @@ -517,13 +479,11 @@ impl ToCss for Display { Display::InlineBlock => dest.write_str("inline-block"), #[cfg(feature = "gecko")] Display::WebkitInlineBox => dest.write_str("-webkit-inline-box"), - #[cfg(any(feature = "servo-layout-2013", feature = "gecko"))] Display::TableCaption => dest.write_str("table-caption"), _ => match (outside, inside) { #[cfg(feature = "gecko")] (DisplayOutside::Inline, DisplayInside::Grid) => dest.write_str("inline-grid"), (DisplayOutside::Inline, DisplayInside::Flex) => dest.write_str("inline-flex"), - #[cfg(any(feature = "servo-layout-2013", feature = "gecko"))] (DisplayOutside::Inline, DisplayInside::Table) => dest.write_str("inline-table"), #[cfg(feature = "gecko")] (DisplayOutside::Block, DisplayInside::Ruby) => dest.write_str("block ruby"), @@ -1607,18 +1567,12 @@ pub enum Appearance { TabScrollArrowBack, #[parse(condition = "ParserContext::chrome_rules_enabled")] TabScrollArrowForward, - /// A toolbar in an application window. - #[parse(condition = "ParserContext::chrome_rules_enabled")] - Toolbar, /// A single toolbar button (with no associated dropdown). #[parse(condition = "ParserContext::chrome_rules_enabled")] Toolbarbutton, /// The dropdown portion of a toolbar button #[parse(condition = "ParserContext::chrome_rules_enabled")] ToolbarbuttonDropdown, - /// The toolbox that contains the toolbars. - #[parse(condition = "ParserContext::chrome_rules_enabled")] - Toolbox, /// A tooltip. #[parse(condition = "ParserContext::chrome_rules_enabled")] Tooltip, diff --git a/servo/components/style/values/specified/color.rs b/servo/components/style/values/specified/color.rs index 3694b4e9bc..f823ba7d30 100644 --- a/servo/components/style/values/specified/color.rs +++ b/servo/components/style/values/specified/color.rs @@ -7,21 +7,20 @@ use super::AllowQuirks; use crate::color::component::ColorComponent; use crate::color::convert::normalize_hue; -use crate::color::parsing::{self, FromParsedColor, NumberOrAngle, NumberOrPercentage}; +use crate::color::parsing::{ + self, ColorParser, FromParsedColor, NumberOrAngle, NumberOrPercentage, +}; use crate::color::{mix::ColorInterpolationMethod, AbsoluteColor, ColorSpace}; use crate::media_queries::Device; use crate::parser::{Parse, ParserContext}; use crate::values::computed::{Color as ComputedColor, Context, ToComputedValue}; -use crate::values::generics::calc::CalcUnits; use crate::values::generics::color::{ ColorMixFlags, GenericCaretColor, GenericColorMix, GenericColorOrAuto, }; -use crate::values::specified::calc::{CalcNode, Leaf}; use crate::values::specified::Percentage; use crate::values::{normalize, CustomIdent}; use cssparser::color::OPAQUE; use cssparser::{color::PredefinedColorSpace, BasicParseErrorKind, ParseErrorKind, Parser, Token}; -use itoa; use std::fmt::{self, Write}; use std::io::Write as IoWrite; use style_traits::{CssType, CssWriter, KeywordsCollectFn, ParseError, StyleParseErrorKind}; @@ -623,156 +622,6 @@ impl FromParsedColor for Color { } } -struct ColorParser<'a, 'b: 'a>(&'a ParserContext<'b>); - -impl<'a, 'b: 'a, 'i: 'a> parsing::ColorParser<'i> for ColorParser<'a, 'b> { - type Output = Color; - - fn parse_number_or_angle<'t>( - &self, - input: &mut Parser<'i, 't>, - allow_none: bool, - ) -> Result<ColorComponent<NumberOrAngle>, ParseError<'i>> { - use crate::values::specified::Angle; - - let location = input.current_source_location(); - let token = input.next()?.clone(); - Ok(match token { - Token::Ident(ref value) if allow_none && value.eq_ignore_ascii_case("none") => { - ColorComponent::None - }, - Token::Dimension { - value, ref unit, .. - } => { - let angle = Angle::parse_dimension(value, unit, /* from_calc = */ false); - - let degrees = match angle { - Ok(angle) => angle.degrees(), - Err(()) => return Err(location.new_unexpected_token_error(token.clone())), - }; - - ColorComponent::Value(NumberOrAngle::Angle { degrees }) - }, - Token::Number { value, .. } => ColorComponent::Value(NumberOrAngle::Number { value }), - Token::Function(ref name) => { - let function = CalcNode::math_function(self.0, name, location)?; - let node = CalcNode::parse(self.0, input, function, CalcUnits::ANGLE)?; - - // If we can resolve the calc node, then use the value. - match node.resolve() { - Ok(Leaf::Number(value)) => { - ColorComponent::Value(NumberOrAngle::Number { value }) - }, - Ok(Leaf::Angle(angle)) => ColorComponent::Value(NumberOrAngle::Angle { - degrees: angle.degrees(), - }), - _ => { - return Err(location.new_custom_error(StyleParseErrorKind::UnspecifiedError)) - }, - } - }, - t => return Err(location.new_unexpected_token_error(t)), - }) - } - - fn parse_percentage<'t>( - &self, - input: &mut Parser<'i, 't>, - allow_none: bool, - ) -> Result<ColorComponent<f32>, ParseError<'i>> { - let location = input.current_source_location(); - - Ok(match *input.next()? { - Token::Ident(ref value) if allow_none && value.eq_ignore_ascii_case("none") => { - ColorComponent::None - }, - Token::Percentage { unit_value, .. } => ColorComponent::Value(unit_value), - Token::Function(ref name) => { - let function = CalcNode::math_function(self.0, name, location)?; - let node = CalcNode::parse(self.0, input, function, CalcUnits::PERCENTAGE)?; - - // If we can resolve the calc node, then use the value. - let Ok(resolved_leaf) = node.resolve() else { - return Err(location.new_custom_error(StyleParseErrorKind::UnspecifiedError)); - }; - if let Leaf::Percentage(value) = resolved_leaf { - ColorComponent::Value(value) - } else { - return Err(location.new_custom_error(StyleParseErrorKind::UnspecifiedError)); - } - }, - ref t => return Err(location.new_unexpected_token_error(t.clone())), - }) - } - - fn parse_number<'t>( - &self, - input: &mut Parser<'i, 't>, - allow_none: bool, - ) -> Result<ColorComponent<f32>, ParseError<'i>> { - let location = input.current_source_location(); - - Ok(match *input.next()? { - Token::Ident(ref value) if allow_none && value.eq_ignore_ascii_case("none") => { - ColorComponent::None - }, - Token::Number { value, .. } => ColorComponent::Value(value), - Token::Function(ref name) => { - let function = CalcNode::math_function(self.0, name, location)?; - let node = CalcNode::parse(self.0, input, function, CalcUnits::empty())?; - - // If we can resolve the calc node, then use the value. - let Ok(resolved_leaf) = node.resolve() else { - return Err(location.new_custom_error(StyleParseErrorKind::UnspecifiedError)); - }; - if let Leaf::Number(value) = resolved_leaf { - ColorComponent::Value(value) - } else { - return Err(location.new_custom_error(StyleParseErrorKind::UnspecifiedError)); - } - }, - ref t => return Err(location.new_unexpected_token_error(t.clone())), - }) - } - - fn parse_number_or_percentage<'t>( - &self, - input: &mut Parser<'i, 't>, - allow_none: bool, - ) -> Result<ColorComponent<NumberOrPercentage>, ParseError<'i>> { - let location = input.current_source_location(); - - Ok(match *input.next()? { - Token::Ident(ref value) if allow_none && value.eq_ignore_ascii_case("none") => { - ColorComponent::None - }, - Token::Number { value, .. } => { - ColorComponent::Value(NumberOrPercentage::Number { value }) - }, - Token::Percentage { unit_value, .. } => { - ColorComponent::Value(NumberOrPercentage::Percentage { unit_value }) - }, - Token::Function(ref name) => { - let function = CalcNode::math_function(self.0, name, location)?; - let node = CalcNode::parse(self.0, input, function, CalcUnits::PERCENTAGE)?; - - // If we can resolve the calc node, then use the value. - let Ok(resolved_leaf) = node.resolve() else { - return Err(location.new_custom_error(StyleParseErrorKind::UnspecifiedError)); - }; - if let Leaf::Percentage(unit_value) = resolved_leaf { - ColorComponent::Value(NumberOrPercentage::Percentage { unit_value }) - } else if let Leaf::Number(value) = resolved_leaf { - ColorComponent::Value(NumberOrPercentage::Number { value }) - } else { - return Err(location.new_custom_error(StyleParseErrorKind::UnspecifiedError)); - } - }, - ref t => return Err(location.new_unexpected_token_error(t.clone())), - }) - } -} - /// Whether to preserve authored colors during parsing. That's useful only if we /// plan to serialize the color back. #[derive(Copy, Clone)] @@ -809,7 +658,7 @@ impl Color { }, }; - let color_parser = ColorParser(&*context); + let color_parser = ColorParser { context: &context }; match input.try_parse(|i| parsing::parse_color_with(&color_parser, i)) { Ok(mut color) => { if let Color::Absolute(ref mut absolute) = color { diff --git a/servo/components/style/values/specified/counters.rs b/servo/components/style/values/specified/counters.rs index 9d8261ce6c..7760be91d7 100644 --- a/servo/components/style/values/specified/counters.rs +++ b/servo/components/style/values/specified/counters.rs @@ -4,7 +4,7 @@ //! Specified types for counter properties. -#[cfg(feature = "servo-layout-2013")] +#[cfg(feature = "servo")] use crate::computed_values::list_style_type::T as ListStyleType; use crate::parser::{Parse, ParserContext}; use crate::values::generics::counters as generics; @@ -12,12 +12,10 @@ use crate::values::generics::counters::CounterPair; #[cfg(feature = "gecko")] use crate::values::generics::CounterStyle; use crate::values::specified::image::Image; -#[cfg(any(feature = "gecko", feature = "servo-layout-2020"))] use crate::values::specified::Attr; use crate::values::specified::Integer; use crate::values::CustomIdent; use cssparser::{Parser, Token}; -#[cfg(any(feature = "gecko", feature = "servo-layout-2013"))] use selectors::parser::SelectorParseErrorKind; use style_traits::{ParseError, StyleParseErrorKind}; @@ -151,7 +149,7 @@ pub type Content = generics::GenericContent<Image>; pub type ContentItem = generics::GenericContentItem<Image>; impl Content { - #[cfg(feature = "servo-layout-2013")] + #[cfg(feature = "servo")] fn parse_counter_style(_: &ParserContext, input: &mut Parser) -> ListStyleType { input .try_parse(|input| { @@ -197,7 +195,6 @@ impl Parse for Content { let mut content = vec![]; let mut has_alt_content = false; loop { - #[cfg(any(feature = "gecko", feature = "servo-layout-2020"))] { if let Ok(image) = input.try_parse(|i| Image::parse_forbid_none(context, i)) { content.push(generics::ContentItem::Image(image)); @@ -212,13 +209,11 @@ impl Parse for Content { }, Ok(&Token::Function(ref name)) => { let result = match_ignore_ascii_case! { &name, - #[cfg(any(feature = "gecko", feature = "servo-layout-2013"))] "counter" => input.parse_nested_block(|input| { let name = CustomIdent::parse(input, &[])?; let style = Content::parse_counter_style(context, input); Ok(generics::ContentItem::Counter(name, style)) }), - #[cfg(any(feature = "gecko", feature = "servo-layout-2013"))] "counters" => input.parse_nested_block(|input| { let name = CustomIdent::parse(input, &[])?; input.expect_comma()?; @@ -226,7 +221,6 @@ impl Parse for Content { let style = Content::parse_counter_style(context, input); Ok(generics::ContentItem::Counters(name, separator, style)) }), - #[cfg(any(feature = "gecko", feature = "servo-layout-2020"))] "attr" => input.parse_nested_block(|input| { Ok(generics::ContentItem::Attr(Attr::parse_function(context, input)?)) }), @@ -240,7 +234,6 @@ impl Parse for Content { }?; content.push(result); }, - #[cfg(any(feature = "gecko", feature = "servo-layout-2013"))] Ok(&Token::Ident(ref ident)) => { content.push(match_ignore_ascii_case! { &ident, "open-quote" => generics::ContentItem::OpenQuote, diff --git a/servo/components/style/values/specified/easing.rs b/servo/components/style/values/specified/easing.rs index 5e4d8ae1ea..7697e6a5d7 100644 --- a/servo/components/style/values/specified/easing.rs +++ b/servo/components/style/values/specified/easing.rs @@ -9,7 +9,7 @@ use crate::values::computed::easing::TimingFunction as ComputedTimingFunction; use crate::values::computed::{Context, ToComputedValue}; use crate::values::generics::easing::TimingFunction as GenericTimingFunction; use crate::values::generics::easing::{StepPosition, TimingKeyword}; -use crate::values::specified::{Integer, Number, Percentage}; +use crate::values::specified::{AnimationName, Integer, Number, Percentage}; use cssparser::{Delimiter, Parser, Token}; use selectors::parser::SelectorParseErrorKind; use style_traits::{ParseError, StyleParseErrorKind}; @@ -140,6 +140,15 @@ impl TimingFunction { Ok(GenericTimingFunction::LinearFunction(builder.build())) } + + /// Returns true if the name matches any keyword. + #[inline] + pub fn match_keywords(name: &AnimationName) -> bool { + if let Some(name) = name.as_atom() { + return name.with_str(|n| TimingKeyword::from_ident(n).is_ok()); + } + false + } } // We need this for converting the specified TimingFunction into computed TimingFunction without diff --git a/servo/components/style/values/specified/effects.rs b/servo/components/style/values/specified/effects.rs index 0453582768..a32390e148 100644 --- a/servo/components/style/values/specified/effects.rs +++ b/servo/components/style/values/specified/effects.rs @@ -28,7 +28,7 @@ use crate::values::specified::{Angle, Number, NumberOrPercentage}; #[cfg(feature = "servo")] use crate::values::Impossible; use crate::Zero; -use cssparser::{self, BasicParseErrorKind, Parser, Token}; +use cssparser::{BasicParseErrorKind, Parser, Token}; use style_traits::{ParseError, StyleParseErrorKind, ValueParseErrorKind}; /// A specified value for a single shadow of the `box-shadow` property. diff --git a/servo/components/style/values/specified/image.rs b/servo/components/style/values/specified/image.rs index 76bbbf85df..bedced1a27 100644 --- a/servo/components/style/values/specified/image.rs +++ b/servo/components/style/values/specified/image.rs @@ -241,7 +241,7 @@ impl Image { let function = input.expect_function()?.clone(); input.parse_nested_block(|input| { Ok(match_ignore_ascii_case! { &function, - #[cfg(feature = "servo-layout-2013")] + #[cfg(feature = "servo")] "paint" => Self::PaintWorklet(PaintWorklet::parse_args(context, input)?), "cross-fade" if cross_fade_enabled() => Self::CrossFade(Box::new(CrossFade::parse_args(context, input, cors_mode, flags)?)), #[cfg(feature = "gecko")] diff --git a/servo/components/style/values/specified/length.rs b/servo/components/style/values/specified/length.rs index d2e1d7d346..17ff43cd6f 100644 --- a/servo/components/style/values/specified/length.rs +++ b/servo/components/style/values/specified/length.rs @@ -97,9 +97,15 @@ pub enum LineHeightBase { impl FontBaseSize { /// Calculate the actual size for a given context pub fn resolve(&self, context: &Context) -> computed::FontSize { + let style = context.style(); match *self { - Self::CurrentStyle => context.style().get_font().clone_font_size(), - Self::InheritedStyle => context.style().get_parent_font().clone_font_size(), + Self::CurrentStyle => style.get_font().clone_font_size(), + Self::InheritedStyle => { + // If we're using the size from our inherited style, we still need to apply our + // own zoom. + let zoom = style.get_box().clone_zoom(); + style.get_parent_font().clone_font_size().zoom(zoom) + }, } } } @@ -351,7 +357,7 @@ impl FontRelativeLength { let reference_size = if context.builder.is_root_element || context.in_media_query { reference_font_size.computed_size() } else { - context.device().root_font_size() + context.device().root_font_size().zoom(context.builder.effective_zoom) }; (reference_size, length) }, @@ -394,19 +400,19 @@ impl FontRelativeLength { // When specified on the root element, the rlh units refer // to the initial values of font and line-height properties. // - let reference_size: CSSPixelLength = - if context.builder.is_root_element || context.in_media_query { - context - .device() - .calc_line_height( - &context.default_style().get_font(), - context.style().writing_mode, - None, - ) - .0 - } else { - context.device().root_line_height() - }; + let reference_size = if context.builder.is_root_element || context.in_media_query { + context + .device() + .calc_line_height( + &context.default_style().get_font(), + context.style().writing_mode, + None, + ) + .0 + } else { + context.device().root_line_height() + }; + let reference_size = reference_size.zoom(context.builder.effective_zoom); (reference_size, length) }, } @@ -668,7 +674,7 @@ impl ViewportPercentageLength { pub fn to_computed_value(&self, context: &Context) -> CSSPixelLength { let (variant, unit, factor) = self.unpack(); let size = context.viewport_size_for_viewport_unit_resolution(variant); - let length = match unit { + let length: app_units::Au = match unit { ViewportUnit::Vw => size.width, ViewportUnit::Vh => size.height, ViewportUnit::Vmin => cmp::min(size.width, size.height), @@ -686,13 +692,15 @@ impl ViewportPercentageLength { }, }; + // NOTE: This is in app units! + let length = context.builder.effective_zoom.zoom(length.0 as f32); + // FIXME: Bug 1396535, we need to fix the extremely small viewport length for transform. - // See bug 989802. We truncate so that adding multiple viewport units - // that add up to 100 does not overflow due to rounding differences. - // We convert appUnits to CSS px manually here to avoid premature clamping by - // going through the Au type. + // See bug 989802. We truncate so that adding multiple viewport units that add up to 100 + // does not overflow due to rounding differences. We convert appUnits to CSS px manually + // here to avoid premature clamping by going through the Au type. let trunc_scaled = - ((length.0 as f64 * factor as f64 / 100.).trunc() / AU_PER_PX as f64) as f32; + ((length as f64 * factor as f64 / 100.).trunc() / AU_PER_PX as f64) as f32; CSSPixelLength::new(crate::values::normalize(trunc_scaled)) } } @@ -797,7 +805,7 @@ impl ToComputedValue for AbsoluteLength { type ComputedValue = CSSPixelLength; fn to_computed_value(&self, context: &Context) -> Self::ComputedValue { - CSSPixelLength::new(context.builder.effective_zoom().zoom(self.to_px())).finite() + CSSPixelLength::new(self.to_px()).zoom(context.builder.effective_zoom).finite() } fn from_computed_value(computed: &Self::ComputedValue) -> Self { @@ -910,6 +918,9 @@ impl ContainerRelativeLength { .builder .add_flags(ComputedValueFlags::USES_CONTAINER_UNITS); + // TODO(emilio, bug 1894104): Need to handle zoom here, probably something like + // container_zoom - effective_zoom or so. See + // https://github.com/w3c/csswg-drafts/issues/10268 let size = context.get_container_size_query(); let (factor, container_length) = match *self { Self::Cqw(v) => (v, size.get_container_width(context)), diff --git a/servo/components/style/values/specified/motion.rs b/servo/components/style/values/specified/motion.rs index 98858c712c..15c76bc640 100644 --- a/servo/components/style/values/specified/motion.rs +++ b/servo/components/style/values/specified/motion.rs @@ -76,10 +76,6 @@ impl Parse for RayFunction { context: &ParserContext, input: &mut Parser<'i, 't>, ) -> Result<Self, ParseError<'i>> { - if !static_prefs::pref!("layout.css.motion-path-ray.enabled") { - return Err(input.new_custom_error(StyleParseErrorKind::UnspecifiedError)); - } - input.expect_function_matching("ray")?; input.parse_nested_block(|i| Self::parse_function_arguments(context, i)) } @@ -154,11 +150,8 @@ impl Parse for OffsetPathFunction { // <offset-path> = <ray()> | <url> | <basic-shape> // https://drafts.fxtf.org/motion-1/#typedef-offset-path - - if static_prefs::pref!("layout.css.motion-path-ray.enabled") { - if let Ok(ray) = input.try_parse(|i| RayFunction::parse(context, i)) { - return Ok(OffsetPathFunction::Ray(ray)); - } + if let Ok(ray) = input.try_parse(|i| RayFunction::parse(context, i)) { + return Ok(OffsetPathFunction::Ray(ray)); } if static_prefs::pref!("layout.css.motion-path-url.enabled") { @@ -167,13 +160,7 @@ impl Parse for OffsetPathFunction { } } - let allowed_shapes = if static_prefs::pref!("layout.css.motion-path-basic-shapes.enabled") { - AllowedBasicShapes::ALL - } else { - AllowedBasicShapes::PATH - }; - - BasicShape::parse(context, input, allowed_shapes, ShapeType::Outline) + BasicShape::parse(context, input, AllowedBasicShapes::ALL, ShapeType::Outline) .map(OffsetPathFunction::Shape) } } @@ -197,9 +184,7 @@ impl Parse for OffsetPath { .ok(); } - if static_prefs::pref!("layout.css.motion-path-coord-box.enabled") && - coord_box.is_none() - { + if coord_box.is_none() { coord_box = input.try_parse(CoordBox::parse).ok(); if coord_box.is_some() { continue; diff --git a/servo/components/style/values/specified/svg_path.rs b/servo/components/style/values/specified/svg_path.rs index 1eb9866dd1..56342b48bb 100644 --- a/servo/components/style/values/specified/svg_path.rs +++ b/servo/components/style/values/specified/svg_path.rs @@ -5,10 +5,13 @@ //! Specified types for SVG Path. use crate::parser::{Parse, ParserContext}; -use crate::values::animated::{lists, Animate, Procedure, ToAnimatedZero}; +use crate::values::animated::{lists, Animate, Procedure}; use crate::values::distance::{ComputeSquaredDistance, SquaredDistance}; +use crate::values::generics::basic_shape::GenericShapeCommand; +use crate::values::generics::basic_shape::{ArcSize, ArcSweep, ByTo, CoordinatePair}; use crate::values::CSSFloat; use cssparser::Parser; +use num_traits::FromPrimitive; use std::fmt::{self, Write}; use std::iter::{Cloned, Peekable}; use std::slice; @@ -70,6 +73,7 @@ impl SVGPathData { #[cfg(feature = "gecko")] pub fn decode_from_f32_array(path: &[f32]) -> Result<Self, ()> { use crate::gecko_bindings::structs::dom::SVGPathSeg_Binding::*; + use crate::values::generics::basic_shape::GenericShapeCommand::*; let mut result: Vec<PathCommand> = Vec::new(); let mut i: usize = 0; @@ -80,85 +84,84 @@ impl SVGPathData { let seg_type = path[i].to_bits() as u16; i = i + 1; match seg_type { - PATHSEG_CLOSEPATH => result.push(PathCommand::ClosePath), + PATHSEG_CLOSEPATH => result.push(Close), PATHSEG_MOVETO_ABS | PATHSEG_MOVETO_REL => { debug_assert!(i + 1 < path.len()); - result.push(PathCommand::MoveTo { + result.push(Move { point: CoordPair::new(path[i], path[i + 1]), - absolute: IsAbsolute::new(seg_type == PATHSEG_MOVETO_ABS), + by_to: ByTo::new(seg_type == PATHSEG_MOVETO_ABS), }); i = i + 2; }, PATHSEG_LINETO_ABS | PATHSEG_LINETO_REL => { debug_assert!(i + 1 < path.len()); - result.push(PathCommand::LineTo { + result.push(Line { point: CoordPair::new(path[i], path[i + 1]), - absolute: IsAbsolute::new(seg_type == PATHSEG_LINETO_ABS), + by_to: ByTo::new(seg_type == PATHSEG_LINETO_ABS), }); i = i + 2; }, PATHSEG_CURVETO_CUBIC_ABS | PATHSEG_CURVETO_CUBIC_REL => { debug_assert!(i + 5 < path.len()); - result.push(PathCommand::CurveTo { + result.push(CubicCurve { control1: CoordPair::new(path[i], path[i + 1]), control2: CoordPair::new(path[i + 2], path[i + 3]), point: CoordPair::new(path[i + 4], path[i + 5]), - absolute: IsAbsolute::new(seg_type == PATHSEG_CURVETO_CUBIC_ABS), + by_to: ByTo::new(seg_type == PATHSEG_CURVETO_CUBIC_ABS), }); i = i + 6; }, PATHSEG_CURVETO_QUADRATIC_ABS | PATHSEG_CURVETO_QUADRATIC_REL => { debug_assert!(i + 3 < path.len()); - result.push(PathCommand::QuadBezierCurveTo { + result.push(QuadCurve { control1: CoordPair::new(path[i], path[i + 1]), point: CoordPair::new(path[i + 2], path[i + 3]), - absolute: IsAbsolute::new(seg_type == PATHSEG_CURVETO_QUADRATIC_ABS), + by_to: ByTo::new(seg_type == PATHSEG_CURVETO_QUADRATIC_ABS), }); i = i + 4; }, PATHSEG_ARC_ABS | PATHSEG_ARC_REL => { debug_assert!(i + 6 < path.len()); - result.push(PathCommand::EllipticalArc { - rx: path[i], - ry: path[i + 1], - angle: path[i + 2], - large_arc_flag: ArcFlag(path[i + 3] != 0.0f32), - sweep_flag: ArcFlag(path[i + 4] != 0.0f32), + result.push(Arc { + radii: CoordPair::new(path[i], path[i + 1]), + rotate: path[i + 2], + arc_size: ArcSize::from_u8((path[i + 3] != 0.0f32) as u8).unwrap(), + arc_sweep: ArcSweep::from_u8((path[i + 4] != 0.0f32) as u8).unwrap(), point: CoordPair::new(path[i + 5], path[i + 6]), - absolute: IsAbsolute::new(seg_type == PATHSEG_ARC_ABS), + by_to: ByTo::new(seg_type == PATHSEG_ARC_ABS), }); i = i + 7; }, PATHSEG_LINETO_HORIZONTAL_ABS | PATHSEG_LINETO_HORIZONTAL_REL => { debug_assert!(i < path.len()); - result.push(PathCommand::HorizontalLineTo { + result.push(HLine { x: path[i], - absolute: IsAbsolute::new(seg_type == PATHSEG_LINETO_HORIZONTAL_ABS), + by_to: ByTo::new(seg_type == PATHSEG_LINETO_HORIZONTAL_ABS), }); i = i + 1; }, PATHSEG_LINETO_VERTICAL_ABS | PATHSEG_LINETO_VERTICAL_REL => { debug_assert!(i < path.len()); - result.push(PathCommand::VerticalLineTo { + result.push(VLine { y: path[i], - absolute: IsAbsolute::new(seg_type == PATHSEG_LINETO_VERTICAL_ABS), + by_to: ByTo::new(seg_type == PATHSEG_LINETO_VERTICAL_ABS), }); i = i + 1; }, PATHSEG_CURVETO_CUBIC_SMOOTH_ABS | PATHSEG_CURVETO_CUBIC_SMOOTH_REL => { debug_assert!(i + 3 < path.len()); - result.push(PathCommand::SmoothCurveTo { + result.push(SmoothCubic { control2: CoordPair::new(path[i], path[i + 1]), point: CoordPair::new(path[i + 2], path[i + 3]), - absolute: IsAbsolute::new(seg_type == PATHSEG_CURVETO_CUBIC_SMOOTH_ABS), + by_to: ByTo::new(seg_type == PATHSEG_CURVETO_CUBIC_SMOOTH_ABS), }); i = i + 4; }, PATHSEG_CURVETO_QUADRATIC_SMOOTH_ABS | PATHSEG_CURVETO_QUADRATIC_SMOOTH_REL => { debug_assert!(i + 1 < path.len()); - result.push(PathCommand::SmoothQuadBezierCurveTo { + result.push(SmoothQuad { point: CoordPair::new(path[i], path[i + 1]), - absolute: IsAbsolute::new(seg_type == PATHSEG_CURVETO_QUADRATIC_SMOOTH_ABS), + by_to: ByTo::new(seg_type == PATHSEG_CURVETO_QUADRATIC_SMOOTH_ABS), }); i = i + 2; }, @@ -215,7 +218,7 @@ impl ToCss for SVGPathData { { let mut writer = SequenceWriter::new(dest, " "); for command in self.commands() { - writer.item(command)?; + writer.write_item(|inner| command.to_css_for_svg(inner))?; } } dest.write_char('"') @@ -268,79 +271,7 @@ impl ComputeSquaredDistance for SVGPathData { /// points of the Bézier curve in the spec. /// /// https://www.w3.org/TR/SVG11/paths.html#PathData -#[derive( - Animate, - Clone, - ComputeSquaredDistance, - Copy, - Debug, - Deserialize, - MallocSizeOf, - PartialEq, - Serialize, - SpecifiedValueInfo, - ToAnimatedZero, - ToComputedValue, - ToResolvedValue, - ToShmem, -)] -#[allow(missing_docs)] -#[repr(C, u8)] -pub enum PathCommand { - /// The unknown type. - /// https://www.w3.org/TR/SVG/paths.html#__svg__SVGPathSeg__PATHSEG_UNKNOWN - Unknown, - /// The "moveto" command. - MoveTo { - point: CoordPair, - absolute: IsAbsolute, - }, - /// The "lineto" command. - LineTo { - point: CoordPair, - absolute: IsAbsolute, - }, - /// The horizontal "lineto" command. - HorizontalLineTo { x: CSSFloat, absolute: IsAbsolute }, - /// The vertical "lineto" command. - VerticalLineTo { y: CSSFloat, absolute: IsAbsolute }, - /// The cubic Bézier curve command. - CurveTo { - control1: CoordPair, - control2: CoordPair, - point: CoordPair, - absolute: IsAbsolute, - }, - /// The smooth curve command. - SmoothCurveTo { - control2: CoordPair, - point: CoordPair, - absolute: IsAbsolute, - }, - /// The quadratic Bézier curve command. - QuadBezierCurveTo { - control1: CoordPair, - point: CoordPair, - absolute: IsAbsolute, - }, - /// The smooth quadratic Bézier curve command. - SmoothQuadBezierCurveTo { - point: CoordPair, - absolute: IsAbsolute, - }, - /// The elliptical arc curve command. - EllipticalArc { - rx: CSSFloat, - ry: CSSFloat, - angle: CSSFloat, - large_arc_flag: ArcFlag, - sweep_flag: ArcFlag, - point: CoordPair, - absolute: IsAbsolute, - }, - /// The "closepath" command. - ClosePath, -} +pub type PathCommand = GenericShapeCommand<CSSFloat, CSSFloat>; /// For internal SVGPath normalization. #[allow(missing_docs)] @@ -355,177 +286,157 @@ impl PathCommand { /// /// See discussion: https://github.com/w3c/svgwg/issues/321 fn normalize(&self, state: &mut PathTraversalState) -> Self { - use self::PathCommand::*; + use crate::values::generics::basic_shape::GenericShapeCommand::*; match *self { - Unknown => Unknown, - ClosePath => { + Close => { state.pos = state.subpath_start; - ClosePath + Close }, - MoveTo { - mut point, - absolute, - } => { - if !absolute.is_yes() { + Move { by_to, mut point } => { + if !by_to.is_abs() { point += state.pos; } state.pos = point; state.subpath_start = point; - MoveTo { + Move { + by_to: ByTo::To, point, - absolute: IsAbsolute::Yes, } }, - LineTo { - mut point, - absolute, - } => { - if !absolute.is_yes() { + Line { by_to, mut point } => { + if !by_to.is_abs() { point += state.pos; } state.pos = point; - LineTo { + Line { + by_to: ByTo::To, point, - absolute: IsAbsolute::Yes, } }, - HorizontalLineTo { mut x, absolute } => { - if !absolute.is_yes() { + HLine { by_to, mut x } => { + if !by_to.is_abs() { x += state.pos.x; } state.pos.x = x; - HorizontalLineTo { - x, - absolute: IsAbsolute::Yes, - } + HLine { by_to: ByTo::To, x } }, - VerticalLineTo { mut y, absolute } => { - if !absolute.is_yes() { + VLine { by_to, mut y } => { + if !by_to.is_abs() { y += state.pos.y; } state.pos.y = y; - VerticalLineTo { - y, - absolute: IsAbsolute::Yes, - } + VLine { by_to: ByTo::To, y } }, - CurveTo { + CubicCurve { + by_to, + mut point, mut control1, mut control2, - mut point, - absolute, } => { - if !absolute.is_yes() { + if !by_to.is_abs() { + point += state.pos; control1 += state.pos; control2 += state.pos; - point += state.pos; } state.pos = point; - CurveTo { + CubicCurve { + by_to: ByTo::To, + point, control1, control2, - point, - absolute: IsAbsolute::Yes, } }, - SmoothCurveTo { - mut control2, + QuadCurve { + by_to, mut point, - absolute, + mut control1, } => { - if !absolute.is_yes() { - control2 += state.pos; + if !by_to.is_abs() { point += state.pos; + control1 += state.pos; } state.pos = point; - SmoothCurveTo { - control2, + QuadCurve { + by_to: ByTo::To, point, - absolute: IsAbsolute::Yes, + control1, } }, - QuadBezierCurveTo { - mut control1, + SmoothCubic { + by_to, mut point, - absolute, + mut control2, } => { - if !absolute.is_yes() { - control1 += state.pos; + if !by_to.is_abs() { point += state.pos; + control2 += state.pos; } state.pos = point; - QuadBezierCurveTo { - control1, + SmoothCubic { + by_to: ByTo::To, point, - absolute: IsAbsolute::Yes, + control2, } }, - SmoothQuadBezierCurveTo { - mut point, - absolute, - } => { - if !absolute.is_yes() { + SmoothQuad { by_to, mut point } => { + if !by_to.is_abs() { point += state.pos; } state.pos = point; - SmoothQuadBezierCurveTo { + SmoothQuad { + by_to: ByTo::To, point, - absolute: IsAbsolute::Yes, } }, - EllipticalArc { - rx, - ry, - angle, - large_arc_flag, - sweep_flag, + Arc { + by_to, mut point, - absolute, + radii, + arc_sweep, + arc_size, + rotate, } => { - if !absolute.is_yes() { + if !by_to.is_abs() { point += state.pos; } state.pos = point; - EllipticalArc { - rx, - ry, - angle, - large_arc_flag, - sweep_flag, + Arc { + by_to: ByTo::To, point, - absolute: IsAbsolute::Yes, + radii, + arc_sweep, + arc_size, + rotate, } }, } } -} -impl ToCss for PathCommand { - fn to_css<W>(&self, dest: &mut CssWriter<W>) -> fmt::Result + /// The serialization of the svg path. + fn to_css_for_svg<W>(&self, dest: &mut CssWriter<W>) -> fmt::Result where W: fmt::Write, { - use self::PathCommand::*; + use crate::values::generics::basic_shape::GenericShapeCommand::*; match *self { - Unknown => dest.write_char('X'), - ClosePath => dest.write_char('Z'), - MoveTo { point, absolute } => { - dest.write_char(if absolute.is_yes() { 'M' } else { 'm' })?; + Close => dest.write_char('Z'), + Move { by_to, point } => { + dest.write_char(if by_to.is_abs() { 'M' } else { 'm' })?; dest.write_char(' ')?; point.to_css(dest) }, - LineTo { point, absolute } => { - dest.write_char(if absolute.is_yes() { 'L' } else { 'l' })?; + Line { by_to, point } => { + dest.write_char(if by_to.is_abs() { 'L' } else { 'l' })?; dest.write_char(' ')?; point.to_css(dest) }, - CurveTo { + CubicCurve { + by_to, + point, control1, control2, - point, - absolute, } => { - dest.write_char(if absolute.is_yes() { 'C' } else { 'c' })?; + dest.write_char(if by_to.is_abs() { 'C' } else { 'c' })?; dest.write_char(' ')?; control1.to_css(dest)?; dest.write_char(' ')?; @@ -533,63 +444,60 @@ impl ToCss for PathCommand { dest.write_char(' ')?; point.to_css(dest) }, - QuadBezierCurveTo { - control1, + QuadCurve { + by_to, point, - absolute, + control1, } => { - dest.write_char(if absolute.is_yes() { 'Q' } else { 'q' })?; + dest.write_char(if by_to.is_abs() { 'Q' } else { 'q' })?; dest.write_char(' ')?; control1.to_css(dest)?; dest.write_char(' ')?; point.to_css(dest) }, - EllipticalArc { - rx, - ry, - angle, - large_arc_flag, - sweep_flag, + Arc { + by_to, point, - absolute, + radii, + arc_sweep, + arc_size, + rotate, } => { - dest.write_char(if absolute.is_yes() { 'A' } else { 'a' })?; - dest.write_char(' ')?; - rx.to_css(dest)?; + dest.write_char(if by_to.is_abs() { 'A' } else { 'a' })?; dest.write_char(' ')?; - ry.to_css(dest)?; + radii.to_css(dest)?; dest.write_char(' ')?; - angle.to_css(dest)?; + rotate.to_css(dest)?; dest.write_char(' ')?; - large_arc_flag.to_css(dest)?; + (arc_size as i32).to_css(dest)?; dest.write_char(' ')?; - sweep_flag.to_css(dest)?; + (arc_sweep as i32).to_css(dest)?; dest.write_char(' ')?; point.to_css(dest) }, - HorizontalLineTo { x, absolute } => { - dest.write_char(if absolute.is_yes() { 'H' } else { 'h' })?; + HLine { by_to, x } => { + dest.write_char(if by_to.is_abs() { 'H' } else { 'h' })?; dest.write_char(' ')?; x.to_css(dest) }, - VerticalLineTo { y, absolute } => { - dest.write_char(if absolute.is_yes() { 'V' } else { 'v' })?; + VLine { by_to, y } => { + dest.write_char(if by_to.is_abs() { 'V' } else { 'v' })?; dest.write_char(' ')?; y.to_css(dest) }, - SmoothCurveTo { - control2, + SmoothCubic { + by_to, point, - absolute, + control2, } => { - dest.write_char(if absolute.is_yes() { 'S' } else { 's' })?; + dest.write_char(if by_to.is_abs() { 'S' } else { 's' })?; dest.write_char(' ')?; control2.to_css(dest)?; dest.write_char(' ')?; point.to_css(dest) }, - SmoothQuadBezierCurveTo { point, absolute } => { - dest.write_char(if absolute.is_yes() { 'T' } else { 't' })?; + SmoothQuad { by_to, point } => { + dest.write_char(if by_to.is_abs() { 'T' } else { 't' })?; dest.write_char(' ')?; point.to_css(dest) }, @@ -597,135 +505,8 @@ impl ToCss for PathCommand { } } -/// The path command absolute type. -#[allow(missing_docs)] -#[derive( - Animate, - Clone, - ComputeSquaredDistance, - Copy, - Debug, - Deserialize, - MallocSizeOf, - PartialEq, - Serialize, - SpecifiedValueInfo, - ToAnimatedZero, - ToComputedValue, - ToResolvedValue, - ToShmem, -)] -#[repr(u8)] -pub enum IsAbsolute { - Yes, - No, -} - -impl IsAbsolute { - /// Return true if this is IsAbsolute::Yes. - #[inline] - pub fn is_yes(&self) -> bool { - *self == IsAbsolute::Yes - } - - /// Return Yes if value is true. Otherwise, return No. - #[inline] - fn new(value: bool) -> Self { - if value { - IsAbsolute::Yes - } else { - IsAbsolute::No - } - } -} - /// The path coord type. -#[allow(missing_docs)] -#[derive( - AddAssign, - Animate, - Clone, - ComputeSquaredDistance, - Copy, - Debug, - Deserialize, - MallocSizeOf, - PartialEq, - Serialize, - SpecifiedValueInfo, - ToAnimatedZero, - ToComputedValue, - ToCss, - ToResolvedValue, - ToShmem, -)] -#[repr(C)] -pub struct CoordPair { - x: CSSFloat, - y: CSSFloat, -} - -impl CoordPair { - /// Create a CoordPair. - #[inline] - pub fn new(x: CSSFloat, y: CSSFloat) -> Self { - CoordPair { x, y } - } -} - -/// The EllipticalArc flag type. -#[derive( - Clone, - Copy, - Debug, - Deserialize, - MallocSizeOf, - PartialEq, - Serialize, - SpecifiedValueInfo, - ToComputedValue, - ToResolvedValue, - ToShmem, -)] -#[repr(C)] -pub struct ArcFlag(bool); - -impl ToCss for ArcFlag { - #[inline] - fn to_css<W>(&self, dest: &mut CssWriter<W>) -> fmt::Result - where - W: fmt::Write, - { - (self.0 as i32).to_css(dest) - } -} - -impl Animate for ArcFlag { - #[inline] - fn animate(&self, other: &Self, procedure: Procedure) -> Result<Self, ()> { - (self.0 as i32) - .animate(&(other.0 as i32), procedure) - .map(|v| ArcFlag(v > 0)) - } -} - -impl ComputeSquaredDistance for ArcFlag { - #[inline] - fn compute_squared_distance(&self, other: &Self) -> Result<SquaredDistance, ()> { - (self.0 as i32).compute_squared_distance(&(other.0 as i32)) - } -} - -impl ToAnimatedZero for ArcFlag { - #[inline] - fn to_animated_zero(&self) -> Result<Self, ()> { - // The 2 ArcFlags in EllipticalArc determine which one of the 4 different arcs will be - // used. (i.e. From 4 combinations). In other words, if we change the flag, we get a - // different arc. Therefore, we return *self. - // https://svgwg.org/svg2-draft/paths.html#PathDataEllipticalArcCommands - Ok(*self) - } -} +pub type CoordPair = CoordinatePair<CSSFloat>; /// SVG Path parser. struct PathParser<'a> { @@ -736,7 +517,7 @@ struct PathParser<'a> { macro_rules! parse_arguments { ( $parser:ident, - $abs:ident, + $by_to:ident, $enum:ident, [ $para:ident => $func:ident $(, $other_para:ident => $other_func:ident)* ] ) => { @@ -747,7 +528,9 @@ macro_rules! parse_arguments { skip_comma_wsp(&mut $parser.chars); let $other_para = $other_func(&mut $parser.chars)?; )* - $parser.path.push(PathCommand::$enum { $para $(, $other_para)*, $abs }); + $parser.path.push( + PathCommand::$enum { $by_to, $para $(, $other_para)* } + ); // End of string or the next character is a possible new command. if !skip_wsp(&mut $parser.chars) || @@ -785,23 +568,23 @@ impl<'a> PathParser<'a> { } let command = self.chars.next().unwrap(); - let abs = if command.is_ascii_uppercase() { - IsAbsolute::Yes + let by_to = if command.is_ascii_uppercase() { + ByTo::To } else { - IsAbsolute::No + ByTo::By }; skip_wsp(&mut self.chars); match command { b'Z' | b'z' => self.parse_closepath(), - b'L' | b'l' => self.parse_lineto(abs), - b'H' | b'h' => self.parse_h_lineto(abs), - b'V' | b'v' => self.parse_v_lineto(abs), - b'C' | b'c' => self.parse_curveto(abs), - b'S' | b's' => self.parse_smooth_curveto(abs), - b'Q' | b'q' => self.parse_quadratic_bezier_curveto(abs), - b'T' | b't' => self.parse_smooth_quadratic_bezier_curveto(abs), - b'A' | b'a' => self.parse_elliptical_arc(abs), + b'L' | b'l' => self.parse_lineto(by_to), + b'H' | b'h' => self.parse_h_lineto(by_to), + b'V' | b'v' => self.parse_v_lineto(by_to), + b'C' | b'c' => self.parse_curveto(by_to), + b'S' | b's' => self.parse_smooth_curveto(by_to), + b'Q' | b'q' => self.parse_quadratic_bezier_curveto(by_to), + b'T' | b't' => self.parse_smooth_quadratic_bezier_curveto(by_to), + b'A' | b'a' => self.parse_elliptical_arc(by_to), _ => return Err(()), }?; } @@ -817,12 +600,8 @@ impl<'a> PathParser<'a> { skip_wsp(&mut self.chars); let point = parse_coord(&mut self.chars)?; - let absolute = if command == b'M' { - IsAbsolute::Yes - } else { - IsAbsolute::No - }; - self.path.push(PathCommand::MoveTo { point, absolute }); + let by_to = if command == b'M' { ByTo::To } else { ByTo::By }; + self.path.push(PathCommand::Move { by_to, point }); // End of string or the next character is a possible new command. if !skip_wsp(&mut self.chars) || self.chars.peek().map_or(true, |c| c.is_ascii_alphabetic()) @@ -833,69 +612,74 @@ impl<'a> PathParser<'a> { // If a moveto is followed by multiple pairs of coordinates, the subsequent // pairs are treated as implicit lineto commands. - self.parse_lineto(absolute) + self.parse_lineto(by_to) } /// Parse "closepath" command. fn parse_closepath(&mut self) -> Result<(), ()> { - self.path.push(PathCommand::ClosePath); + self.path.push(PathCommand::Close); Ok(()) } /// Parse "lineto" command. - fn parse_lineto(&mut self, absolute: IsAbsolute) -> Result<(), ()> { - parse_arguments!(self, absolute, LineTo, [ point => parse_coord ]) + fn parse_lineto(&mut self, by_to: ByTo) -> Result<(), ()> { + parse_arguments!(self, by_to, Line, [ point => parse_coord ]) } /// Parse horizontal "lineto" command. - fn parse_h_lineto(&mut self, absolute: IsAbsolute) -> Result<(), ()> { - parse_arguments!(self, absolute, HorizontalLineTo, [ x => parse_number ]) + fn parse_h_lineto(&mut self, by_to: ByTo) -> Result<(), ()> { + parse_arguments!(self, by_to, HLine, [ x => parse_number ]) } /// Parse vertical "lineto" command. - fn parse_v_lineto(&mut self, absolute: IsAbsolute) -> Result<(), ()> { - parse_arguments!(self, absolute, VerticalLineTo, [ y => parse_number ]) + fn parse_v_lineto(&mut self, by_to: ByTo) -> Result<(), ()> { + parse_arguments!(self, by_to, VLine, [ y => parse_number ]) } /// Parse cubic Bézier curve command. - fn parse_curveto(&mut self, absolute: IsAbsolute) -> Result<(), ()> { - parse_arguments!(self, absolute, CurveTo, [ + fn parse_curveto(&mut self, by_to: ByTo) -> Result<(), ()> { + parse_arguments!(self, by_to, CubicCurve, [ control1 => parse_coord, control2 => parse_coord, point => parse_coord ]) } /// Parse smooth "curveto" command. - fn parse_smooth_curveto(&mut self, absolute: IsAbsolute) -> Result<(), ()> { - parse_arguments!(self, absolute, SmoothCurveTo, [ + fn parse_smooth_curveto(&mut self, by_to: ByTo) -> Result<(), ()> { + parse_arguments!(self, by_to, SmoothCubic, [ control2 => parse_coord, point => parse_coord ]) } /// Parse quadratic Bézier curve command. - fn parse_quadratic_bezier_curveto(&mut self, absolute: IsAbsolute) -> Result<(), ()> { - parse_arguments!(self, absolute, QuadBezierCurveTo, [ + fn parse_quadratic_bezier_curveto(&mut self, by_to: ByTo) -> Result<(), ()> { + parse_arguments!(self, by_to, QuadCurve, [ control1 => parse_coord, point => parse_coord ]) } /// Parse smooth quadratic Bézier curveto command. - fn parse_smooth_quadratic_bezier_curveto(&mut self, absolute: IsAbsolute) -> Result<(), ()> { - parse_arguments!(self, absolute, SmoothQuadBezierCurveTo, [ point => parse_coord ]) + fn parse_smooth_quadratic_bezier_curveto(&mut self, by_to: ByTo) -> Result<(), ()> { + parse_arguments!(self, by_to, SmoothQuad, [ point => parse_coord ]) } /// Parse elliptical arc curve command. - fn parse_elliptical_arc(&mut self, absolute: IsAbsolute) -> Result<(), ()> { + fn parse_elliptical_arc(&mut self, by_to: ByTo) -> Result<(), ()> { // Parse a flag whose value is '0' or '1'; otherwise, return Err(()). - let parse_flag = |iter: &mut Peekable<Cloned<slice::Iter<u8>>>| match iter.next() { - Some(c) if c == b'0' || c == b'1' => Ok(ArcFlag(c == b'1')), + let parse_arc_size = |iter: &mut Peekable<Cloned<slice::Iter<u8>>>| match iter.next() { + Some(c) if c == b'1' => Ok(ArcSize::Large), + Some(c) if c == b'0' => Ok(ArcSize::Small), + _ => Err(()), + }; + let parse_arc_sweep = |iter: &mut Peekable<Cloned<slice::Iter<u8>>>| match iter.next() { + Some(c) if c == b'1' => Ok(ArcSweep::Cw), + Some(c) if c == b'0' => Ok(ArcSweep::Ccw), _ => Err(()), }; - parse_arguments!(self, absolute, EllipticalArc, [ - rx => parse_number, - ry => parse_number, - angle => parse_number, - large_arc_flag => parse_flag, - sweep_flag => parse_flag, + parse_arguments!(self, by_to, Arc, [ + radii => parse_coord, + rotate => parse_number, + arc_size => parse_arc_size, + arc_sweep => parse_arc_sweep, point => parse_coord ]) } diff --git a/servo/components/style/values/specified/text.rs b/servo/components/style/values/specified/text.rs index 0e70bd26ac..e26a17ba27 100644 --- a/servo/components/style/values/specified/text.rs +++ b/servo/components/style/values/specified/text.rs @@ -454,7 +454,6 @@ pub enum TextAlignKeyword { Left, Right, Center, - #[cfg(any(feature = "gecko", feature = "servo-layout-2013"))] Justify, #[css(skip)] #[cfg(feature = "gecko")] @@ -466,11 +465,11 @@ pub enum TextAlignKeyword { MozLeft, #[cfg(feature = "gecko")] MozRight, - #[cfg(feature = "servo-layout-2013")] + #[cfg(feature = "servo")] ServoCenter, - #[cfg(feature = "servo-layout-2013")] + #[cfg(feature = "servo")] ServoLeft, - #[cfg(feature = "servo-layout-2013")] + #[cfg(feature = "servo")] ServoRight, } |