Mirrors/servo
1
0
Fork 0
mirror of https://github.com/servo/servo.git synced 2025-08-03 12:40:06 +01:00
Code Issues Projects Releases Packages Wiki Activity

style: Properly track whether <angle> or <time> values came from calc() expressions.

Browse source
This commit is contained in:
Emilio Cobos Álvarez 2017-03-27 01:45:22 +02:00
parent c654c05884
commit fc72f096a0
No known key found for this signature in database
GPG key ID: 056B727BB9C1027C
10 changed files with 281 additions and 90 deletions
Download patch file Download diff file Expand all files Collapse all files

9
components/style/properties/helpers/animated_properties.mako.rs
View file

@ -36,7 +36,6 @@ use values::computed::{CalcLengthOrPercentage, Context, LengthOrPercentage};
use values::computed::{MaxLength, MinLength};
use values::computed::position::{HorizontalPosition, Position, VerticalPosition};
use values::computed::ToComputedValue;
use values::specified::Angle as SpecifiedAngle;
@ -455,7 +454,7 @@ impl Interpolate for i32 {
impl Interpolate for Angle {
#[inline]
fn interpolate(&self, other: &Angle, progress: f64) -> Result<Self, ()> {
self.radians().interpolate(&other.radians(), progress).map(Angle)
self.radians().interpolate(&other.radians(), progress).map(Angle::from_radians)
}
}
@ -952,7 +951,7 @@ fn build_identity_transform_list(list: &[TransformOperation]) -> Vec<TransformOp
result.push(TransformOperation::Matrix(identity));
}
TransformOperation::Skew(..) => {
result.push(TransformOperation::Skew(Angle(0.0), Angle(0.0)));
result.push(TransformOperation::Skew(Angle::zero(), Angle::zero()))
}
TransformOperation::Translate(..) => {
result.push(TransformOperation::Translate(LengthOrPercentage::zero(),
@ -963,7 +962,7 @@ fn build_identity_transform_list(list: &[TransformOperation]) -> Vec<TransformOp
result.push(TransformOperation::Scale(1.0, 1.0, 1.0));
}
TransformOperation::Rotate(..) => {
result.push(TransformOperation::Rotate(0.0, 0.0, 1.0, Angle(0.0)));
result.push(TransformOperation::Rotate(0.0, 0.0, 1.0, Angle::zero()));
}
TransformOperation::Perspective(..) => {
// http://dev.w3.org/csswg/css-transforms/#identity-transform-function
@ -1052,7 +1051,7 @@ fn interpolate_transform_list(from_list: &[TransformOperation],
}
/// https://drafts.csswg.org/css-transforms/#Rotate3dDefined
fn rotate_to_matrix(x: f32, y: f32, z: f32, a: SpecifiedAngle) -> ComputedMatrix {
fn rotate_to_matrix(x: f32, y: f32, z: f32, a: Angle) -> ComputedMatrix {
let half_rad = a.radians() / 2.0;
let sc = (half_rad).sin() * (half_rad).cos();
let sq = (half_rad).sin().powi(2);

28
components/style/properties/longhand/box.mako.rs
View file

@ -419,13 +419,13 @@ ${helpers.single_keyword("overflow-x", "visible hidden scroll auto",
}
#[inline]
pub fn get_initial_value() -> Time {
Time(0.0)
pub fn get_initial_value() -> computed_value::T {
computed_value::T::zero()
}
#[inline]
pub fn get_initial_specified_value() -> SpecifiedValue {
SpecifiedValue(0.0)
Time::zero()
}
pub fn parse(context: &ParserContext, input: &mut Parser) -> Result<SpecifiedValue,()> {
@ -1221,7 +1221,7 @@ ${helpers.predefined_type("scroll-snap-coordinate",
let second = input.try(|input| {
try!(input.expect_comma());
specified::Angle::parse(context, input)
}).unwrap_or(specified::Angle(0.0));
}).unwrap_or(specified::Angle::zero());
Ok((first, second))
}
@ -1581,14 +1581,14 @@ ${helpers.predefined_type("scroll-snap-coordinate",
"skewx" => {
try!(input.parse_nested_block(|input| {
let theta_x = try!(specified::Angle::parse(context,input));
result.push(SpecifiedOperation::Skew(theta_x, specified::Angle(0.0)));
result.push(SpecifiedOperation::Skew(theta_x, specified::Angle::zero()));
Ok(())
}))
},
"skewy" => {
try!(input.parse_nested_block(|input| {
let theta_y = try!(specified::Angle::parse(context,input));
result.push(SpecifiedOperation::Skew(specified::Angle(0.0), theta_y));
result.push(SpecifiedOperation::Skew(specified::Angle::zero(), theta_y));
Ok(())
}))
},
@ -1640,11 +1640,13 @@ ${helpers.predefined_type("scroll-snap-coordinate",
let ax = ax.to_computed_value(context);
let ay = ay.to_computed_value(context);
let az = az.to_computed_value(context);
let theta = theta.to_computed_value(context);
let len = (ax * ax + ay * ay + az * az).sqrt();
result.push(computed_value::ComputedOperation::Rotate(ax / len, ay / len, az / len, theta));
}
SpecifiedOperation::Skew(theta_x, theta_y) => {
result.push(computed_value::ComputedOperation::Skew(theta_x, theta_y));
result.push(computed_value::ComputedOperation::Skew(theta_x.to_computed_value(context),
theta_y.to_computed_value(context)));
}
SpecifiedOperation::Perspective(ref d) => {
result.push(computed_value::ComputedOperation::Perspective(d.to_computed_value(context)));
@ -1658,7 +1660,7 @@ ${helpers.predefined_type("scroll-snap-coordinate",
#[inline]
fn from_computed_value(computed: &computed_value::T) -> Self {
SpecifiedValue(computed.0.as_ref().map(|computed| {
let mut result = vec!();
let mut result = vec![];
for operation in computed {
match *operation {
computed_value::ComputedOperation::Matrix(ref matrix) => {
@ -1678,15 +1680,17 @@ ${helpers.predefined_type("scroll-snap-coordinate",
Number::from_computed_value(sy),
Number::from_computed_value(sz)));
}
computed_value::ComputedOperation::Rotate(ref ax, ref ay, ref az, theta) => {
computed_value::ComputedOperation::Rotate(ref ax, ref ay, ref az, ref theta) => {
result.push(SpecifiedOperation::Rotate(
Number::from_computed_value(ax),
Number::from_computed_value(ay),
Number::from_computed_value(az),
theta));
specified::Angle::from_computed_value(theta)));
}
computed_value::ComputedOperation::Skew(theta_x, theta_y) => {
result.push(SpecifiedOperation::Skew(theta_x, theta_y));
computed_value::ComputedOperation::Skew(ref theta_x, ref theta_y) => {
result.push(SpecifiedOperation::Skew(
specified::Angle::from_computed_value(theta_x),
specified::Angle::from_computed_value(theta_y)))
}
computed_value::ComputedOperation::Perspective(ref d) => {
result.push(SpecifiedOperation::Perspective(

29
components/style/properties/longhand/inherited_box.mako.rs
View file

@ -96,7 +96,7 @@ ${helpers.single_keyword("image-rendering",
use std::f32::consts::PI;
use values::CSSFloat;
const TWO_PI: CSSFloat = 2.0*PI;
const TWO_PI: CSSFloat = 2.0 * PI;
#[derive(Clone, PartialEq, Copy, Debug)]
#[cfg_attr(feature = "servo", derive(HeapSizeOf))]
@ -125,7 +125,7 @@ ${helpers.single_keyword("image-rendering",
}
pub mod computed_value {
use values::specified::Angle;
use values::computed::Angle;
#[derive(Clone, PartialEq, Copy, Debug)]
#[cfg_attr(feature = "servo", derive(HeapSizeOf))]
@ -135,36 +135,35 @@ ${helpers.single_keyword("image-rendering",
}
}
const INITIAL_ANGLE: Angle = Angle(0.0);
#[inline]
pub fn get_initial_value() -> computed_value::T {
computed_value::T::AngleWithFlipped(INITIAL_ANGLE, false)
computed_value::T::AngleWithFlipped(computed::Angle::zero(), false)
}
// According to CSS Content Module Level 3:
// The computed value of the property is calculated by rounding the specified angle
// to the nearest quarter-turn, rounding away from 0, then moduloing the value by 1 turn.
#[inline]
fn normalize_angle(angle: &Angle) -> Angle {
fn normalize_angle(angle: &computed::Angle) -> computed::Angle {
let radians = angle.radians();
let rounded_quarter_turns = (4.0 * radians / TWO_PI).round();
let normalized_quarter_turns = (rounded_quarter_turns % 4.0 + 4.0) % 4.0;
let normalized_radians = normalized_quarter_turns/4.0 * TWO_PI;
Angle::from_radians(normalized_radians)
computed::Angle::from_radians(normalized_radians)
}
impl ToComputedValue for SpecifiedValue {
type ComputedValue = computed_value::T;
#[inline]
fn to_computed_value(&self, _: &Context) -> computed_value::T {
fn to_computed_value(&self, context: &Context) -> computed_value::T {
if let Some(ref angle) = self.angle {
let normalized_angle = normalize_angle(angle);
let angle = angle.to_computed_value(context);
let normalized_angle = normalize_angle(&angle);
computed_value::T::AngleWithFlipped(normalized_angle, self.flipped)
} else {
if self.flipped {
computed_value::T::AngleWithFlipped(INITIAL_ANGLE, true)
computed_value::T::AngleWithFlipped(computed::Angle::zero(), true)
} else {
computed_value::T::FromImage
}
@ -175,8 +174,12 @@ ${helpers.single_keyword("image-rendering",
fn from_computed_value(computed: &computed_value::T) -> Self {
match *computed {
computed_value::T::FromImage => SpecifiedValue { angle: None, flipped: false },
computed_value::T::AngleWithFlipped(angle, flipped) =>
SpecifiedValue { angle: Some(angle), flipped: flipped },
computed_value::T::AngleWithFlipped(ref angle, flipped) => {
SpecifiedValue {
angle: Some(Angle::from_computed_value(angle)),
flipped: flipped,
}
}
}
}
}
@ -205,7 +208,7 @@ ${helpers.single_keyword("image-rendering",
let angle = input.try(|input| Angle::parse(context, input)).ok();
let flipped = input.try(|input| input.expect_ident_matching("flip")).is_ok();
let explicit_angle = if angle.is_none() && !flipped {
Some(INITIAL_ANGLE)
Some(Angle::zero())
} else {
angle
};