diff options
Diffstat (limited to 'servo/components/style/values/specified/motion.rs')
| -rw-r--r-- | servo/components/style/values/specified/motion.rs | 343 |
1 files changed, 343 insertions, 0 deletions
diff --git a/servo/components/style/values/specified/motion.rs b/servo/components/style/values/specified/motion.rs new file mode 100644 index 0000000000..98858c712c --- /dev/null +++ b/servo/components/style/values/specified/motion.rs @@ -0,0 +1,343 @@ +/* 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/. */ + +//! Specified types for CSS values that are related to motion path. + +use crate::parser::{Parse, ParserContext}; +use crate::values::computed::motion::OffsetRotate as ComputedOffsetRotate; +use crate::values::computed::{Context, ToComputedValue}; +use crate::values::generics::motion as generics; +use crate::values::specified::basic_shape::BasicShape; +use crate::values::specified::position::{HorizontalPosition, VerticalPosition}; +use crate::values::specified::url::SpecifiedUrl; +use crate::values::specified::{Angle, Position}; +use crate::Zero; +use cssparser::Parser; +use style_traits::{ParseError, StyleParseErrorKind}; + +/// The specified value of ray() function. +pub type RayFunction = generics::GenericRayFunction<Angle, Position>; + +/// The specified value of <offset-path>. +pub type OffsetPathFunction = + generics::GenericOffsetPathFunction<BasicShape, RayFunction, SpecifiedUrl>; + +/// The specified value of `offset-path`. +pub type OffsetPath = generics::GenericOffsetPath<OffsetPathFunction>; + +/// The specified value of `offset-position`. +pub type OffsetPosition = generics::GenericOffsetPosition<HorizontalPosition, VerticalPosition>; + +/// The <coord-box> value, which defines the box that the <offset-path> sizes into. +/// https://drafts.fxtf.org/motion-1/#valdef-offset-path-coord-box +/// +/// <coord-box> = content-box | padding-box | border-box | fill-box | stroke-box | view-box +/// https://drafts.csswg.org/css-box-4/#typedef-coord-box +#[allow(missing_docs)] +#[derive( + Animate, + Clone, + ComputeSquaredDistance, + Copy, + Debug, + Deserialize, + MallocSizeOf, + Parse, + PartialEq, + Serialize, + SpecifiedValueInfo, + ToAnimatedValue, + ToComputedValue, + ToCss, + ToResolvedValue, + ToShmem, +)] +#[repr(u8)] +pub enum CoordBox { + ContentBox, + PaddingBox, + BorderBox, + FillBox, + StrokeBox, + ViewBox, +} + +impl CoordBox { + /// Returns true if it is default value, border-box. + #[inline] + pub fn is_default(&self) -> bool { + matches!(*self, Self::BorderBox) + } +} + +impl Parse for RayFunction { + fn parse<'i, 't>( + 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)) + } +} + +impl RayFunction { + /// Parse the inner arguments of a `ray` function. + fn parse_function_arguments<'i, 't>( + context: &ParserContext, + input: &mut Parser<'i, 't>, + ) -> Result<Self, ParseError<'i>> { + use crate::values::specified::PositionOrAuto; + + let mut angle = None; + let mut size = None; + let mut contain = false; + let mut position = None; + loop { + if angle.is_none() { + angle = input.try_parse(|i| Angle::parse(context, i)).ok(); + } + + if size.is_none() { + size = input.try_parse(generics::RaySize::parse).ok(); + if size.is_some() { + continue; + } + } + + if !contain { + contain = input + .try_parse(|i| i.expect_ident_matching("contain")) + .is_ok(); + if contain { + continue; + } + } + + if position.is_none() { + if input.try_parse(|i| i.expect_ident_matching("at")).is_ok() { + let pos = Position::parse(context, input)?; + position = Some(PositionOrAuto::Position(pos)); + } + + if position.is_some() { + continue; + } + } + break; + } + + if angle.is_none() { + return Err(input.new_custom_error(StyleParseErrorKind::UnspecifiedError)); + } + + Ok(RayFunction { + angle: angle.unwrap(), + // If no <ray-size> is specified it defaults to closest-side. + size: size.unwrap_or(generics::RaySize::ClosestSide), + contain, + position: position.unwrap_or(PositionOrAuto::auto()), + }) + } +} + +impl Parse for OffsetPathFunction { + fn parse<'i, 't>( + context: &ParserContext, + input: &mut Parser<'i, 't>, + ) -> Result<Self, ParseError<'i>> { + use crate::values::specified::basic_shape::{AllowedBasicShapes, ShapeType}; + + // <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 static_prefs::pref!("layout.css.motion-path-url.enabled") { + if let Ok(url) = input.try_parse(|i| SpecifiedUrl::parse(context, i)) { + return Ok(OffsetPathFunction::Url(url)); + } + } + + 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) + .map(OffsetPathFunction::Shape) + } +} + +impl Parse for OffsetPath { + fn parse<'i, 't>( + context: &ParserContext, + input: &mut Parser<'i, 't>, + ) -> Result<Self, ParseError<'i>> { + // Parse none. + if input.try_parse(|i| i.expect_ident_matching("none")).is_ok() { + return Ok(OffsetPath::none()); + } + + let mut path = None; + let mut coord_box = None; + loop { + if path.is_none() { + path = input + .try_parse(|i| OffsetPathFunction::parse(context, i)) + .ok(); + } + + if static_prefs::pref!("layout.css.motion-path-coord-box.enabled") && + coord_box.is_none() + { + coord_box = input.try_parse(CoordBox::parse).ok(); + if coord_box.is_some() { + continue; + } + } + break; + } + + if let Some(p) = path { + return Ok(OffsetPath::OffsetPath { + path: Box::new(p), + coord_box: coord_box.unwrap_or(CoordBox::BorderBox), + }); + } + + match coord_box { + Some(c) => Ok(OffsetPath::CoordBox(c)), + None => Err(input.new_custom_error(StyleParseErrorKind::UnspecifiedError)), + } + } +} + +/// The direction of offset-rotate. +#[derive( + Clone, Copy, Debug, MallocSizeOf, Parse, PartialEq, SpecifiedValueInfo, ToCss, ToShmem, +)] +#[repr(u8)] +pub enum OffsetRotateDirection { + /// Unspecified direction keyword. + #[css(skip)] + None, + /// 0deg offset (face forward). + Auto, + /// 180deg offset (face backward). + Reverse, +} + +impl OffsetRotateDirection { + /// Returns true if it is none (i.e. the keyword is not specified). + #[inline] + fn is_none(&self) -> bool { + *self == OffsetRotateDirection::None + } +} + +#[inline] +fn direction_specified_and_angle_is_zero(direction: &OffsetRotateDirection, angle: &Angle) -> bool { + !direction.is_none() && angle.is_zero() +} + +/// The specified offset-rotate. +/// The syntax is: "[ auto | reverse ] || <angle>" +/// +/// https://drafts.fxtf.org/motion-1/#offset-rotate-property +#[derive(Clone, Copy, Debug, MallocSizeOf, PartialEq, SpecifiedValueInfo, ToCss, ToShmem)] +pub struct OffsetRotate { + /// [auto | reverse]. + #[css(skip_if = "OffsetRotateDirection::is_none")] + direction: OffsetRotateDirection, + /// <angle>. + /// If direction is None, this is a fixed angle which indicates a + /// constant clockwise rotation transformation applied to it by this + /// specified rotation angle. Otherwise, the angle will be added to + /// the angle of the direction in layout. + #[css(contextual_skip_if = "direction_specified_and_angle_is_zero")] + angle: Angle, +} + +impl OffsetRotate { + /// Returns the initial value, auto. + #[inline] + pub fn auto() -> Self { + OffsetRotate { + direction: OffsetRotateDirection::Auto, + angle: Angle::zero(), + } + } + + /// Returns true if self is auto 0deg. + #[inline] + pub fn is_auto(&self) -> bool { + self.direction == OffsetRotateDirection::Auto && self.angle.is_zero() + } +} + +impl Parse for OffsetRotate { + fn parse<'i, 't>( + context: &ParserContext, + input: &mut Parser<'i, 't>, + ) -> Result<Self, ParseError<'i>> { + let location = input.current_source_location(); + let mut direction = input.try_parse(OffsetRotateDirection::parse); + let angle = input.try_parse(|i| Angle::parse(context, i)); + if direction.is_err() { + // The direction and angle could be any order, so give it a change to parse + // direction again. + direction = input.try_parse(OffsetRotateDirection::parse); + } + + if direction.is_err() && angle.is_err() { + return Err(location.new_custom_error(StyleParseErrorKind::UnspecifiedError)); + } + + Ok(OffsetRotate { + direction: direction.unwrap_or(OffsetRotateDirection::None), + angle: angle.unwrap_or(Zero::zero()), + }) + } +} + +impl ToComputedValue for OffsetRotate { + type ComputedValue = ComputedOffsetRotate; + + #[inline] + fn to_computed_value(&self, context: &Context) -> Self::ComputedValue { + use crate::values::computed::Angle as ComputedAngle; + + ComputedOffsetRotate { + auto: !self.direction.is_none(), + angle: if self.direction == OffsetRotateDirection::Reverse { + // The computed value should always convert "reverse" into "auto". + // e.g. "reverse calc(20deg + 10deg)" => "auto 210deg" + self.angle.to_computed_value(context) + ComputedAngle::from_degrees(180.0) + } else { + self.angle.to_computed_value(context) + }, + } + } + + #[inline] + fn from_computed_value(computed: &Self::ComputedValue) -> Self { + OffsetRotate { + direction: if computed.auto { + OffsetRotateDirection::Auto + } else { + OffsetRotateDirection::None + }, + angle: ToComputedValue::from_computed_value(&computed.angle), + } + } +} |