From 83e3394904ff18839737452a68c8aa02f83f3b34 Mon Sep 17 00:00:00 2001 From: Manish Goregaokar Date: Mon, 11 Sep 2017 16:26:49 -0700 Subject: [PATCH 1/4] stylo: Preserve the variant of translate() values in computed transforms --- components/style/properties/gecko.mako.rs | 7 ++++ .../helpers/animated_properties.mako.rs | 15 +++++++++ .../style/properties/longhand/box.mako.rs | 32 +++++++++++-------- components/style/values/computed/transform.rs | 17 ++++++++++ 4 files changed, 57 insertions(+), 14 deletions(-) diff --git a/components/style/properties/gecko.mako.rs b/components/style/properties/gecko.mako.rs index 965bf955127..38bb53e4df3 100644 --- a/components/style/properties/gecko.mako.rs +++ b/components/style/properties/gecko.mako.rs @@ -3069,6 +3069,9 @@ fn static_assert() { ${transform_function_arm("MatrixWithPercents", "matrix3d", ["number"] * 12 + ["lop"] * 2 + ["length"] + ["number"])} ${transform_function_arm("Skew", "skew", ["angle"] * 2)} + ${transform_function_arm("TranslateX", "translatex", ["lop"])} + ${transform_function_arm("TranslateY", "translatey", ["lop"])} + ${transform_function_arm("TranslateZ", "translatez", ["length"])} ${transform_function_arm("Translate", "translate3d", ["lop", "lop", "length"])} ${transform_function_arm("Scale", "scale3d", ["number"] * 3)} ${transform_function_arm("Rotate", "rotate3d", ["number"] * 3 + ["angle"])} @@ -3189,6 +3192,10 @@ fn static_assert() { match transform_function { ${computed_operation_arm("Matrix", "matrix3d", ["number"] * 16)} ${computed_operation_arm("Skew", "skew", ["angle"] * 2)} + + ${computed_operation_arm("TranslateX", "translatex", ["lop"])} + ${computed_operation_arm("TranslateY", "translatey", ["lop"])} + ${computed_operation_arm("TranslateZ", "translatez", ["length"])} ${computed_operation_arm("Translate", "translate3d", ["lop", "lop", "length"])} ${computed_operation_arm("Scale", "scale3d", ["number"] * 3)} ${computed_operation_arm("Rotate", "rotate3d", ["number"] * 3 + ["angle"])} diff --git a/components/style/properties/helpers/animated_properties.mako.rs b/components/style/properties/helpers/animated_properties.mako.rs index 0f1db632c91..1bdd06ef33a 100644 --- a/components/style/properties/helpers/animated_properties.mako.rs +++ b/components/style/properties/helpers/animated_properties.mako.rs @@ -1135,6 +1135,21 @@ impl ToAnimatedZero for TransformOperation { sy.to_animated_zero()?, )) }, + TransformOperation::TranslateX(ref tx) => { + Ok(TransformOperation::TranslateX( + tx.to_animated_zero()? + )) + }, + TransformOperation::TranslateY(ref ty) => { + Ok(TransformOperation::TranslateY( + ty.to_animated_zero()? + )) + }, + TransformOperation::TranslateZ(ref tz) => { + Ok(TransformOperation::TranslateZ( + tz.to_animated_zero()? + )) + }, TransformOperation::Translate(ref tx, ref ty, ref tz) => { Ok(TransformOperation::Translate( tx.to_animated_zero()?, diff --git a/components/style/properties/longhand/box.mako.rs b/components/style/properties/longhand/box.mako.rs index 52befd9c67d..03af3b83670 100644 --- a/components/style/properties/longhand/box.mako.rs +++ b/components/style/properties/longhand/box.mako.rs @@ -683,6 +683,9 @@ ${helpers.predefined_type( // For `-moz-transform` matrix and matrix3d. MatrixWithPercents(ComputedMatrixWithPercents), Skew(computed::Angle, computed::Angle), + TranslateX(LengthOrPercentage), + TranslateY(LengthOrPercentage), + TranslateZ(Length), Translate(computed::LengthOrPercentage, computed::LengthOrPercentage, computed::Length), @@ -1262,24 +1265,15 @@ ${helpers.predefined_type( } SpecifiedOperation::TranslateX(ref tx) => { let tx = tx.to_computed_value(context); - result.push(computed_value::ComputedOperation::Translate( - tx, - computed::length::LengthOrPercentage::zero(), - computed::length::Length::new(0.))); + result.push(computed_value::ComputedOperation::TranslateX(tx)); } SpecifiedOperation::TranslateY(ref ty) => { let ty = ty.to_computed_value(context); - result.push(computed_value::ComputedOperation::Translate( - computed::length::LengthOrPercentage::zero(), - ty, - computed::length::Length::new(0.))); + result.push(computed_value::ComputedOperation::TranslateY(ty)); } SpecifiedOperation::TranslateZ(ref tz) => { let tz = tz.to_computed_value(context); - result.push(computed_value::ComputedOperation::Translate( - computed::length::LengthOrPercentage::zero(), - computed::length::LengthOrPercentage::zero(), - tz)); + result.push(computed_value::ComputedOperation::TranslateZ(tz)); } SpecifiedOperation::Translate3D(ref tx, ref ty, ref tz) => { let tx = tx.to_computed_value(context); @@ -1423,9 +1417,19 @@ ${helpers.predefined_type( m44: Number::from_computed_value(&computed.m44), }); } + computed_value::ComputedOperation::TranslateX(ref tx) => { + result.push(SpecifiedOperation::TranslateX( + ToComputedValue::from_computed_value(tx))); + } + computed_value::ComputedOperation::TranslateY(ref ty) => { + result.push(SpecifiedOperation::TranslateY( + ToComputedValue::from_computed_value(ty))); + } + computed_value::ComputedOperation::TranslateZ(ref tz) => { + result.push(SpecifiedOperation::TranslateZ( + ToComputedValue::from_computed_value(tz))); + } computed_value::ComputedOperation::Translate(ref tx, ref ty, ref tz) => { - // XXXManishearth we lose information here; perhaps we should try to - // recover the original function? Not sure if this can be observed. result.push(SpecifiedOperation::Translate3D( ToComputedValue::from_computed_value(tx), ToComputedValue::from_computed_value(ty), diff --git a/components/style/values/computed/transform.rs b/components/style/values/computed/transform.rs index 21c98c50d99..88910e0ff63 100644 --- a/components/style/values/computed/transform.rs +++ b/components/style/values/computed/transform.rs @@ -92,6 +92,23 @@ impl TransformList { ComputedOperation::Scale(sx, sy, sz) => { Transform3D::create_scale(sx, sy, sz) } + ComputedOperation::TranslateX(tx) => { + let tx = match reference_box { + Some(relative_border_box) => tx.to_used_value(relative_border_box.size.width).to_f32_px(), + None => extract_pixel_length(&tx), + }; + Transform3D::create_translation(tx, 0., 0.) + } + ComputedOperation::TranslateY(ty) => { + let ty = match reference_box { + Some(relative_border_box) => ty.to_used_value(relative_border_box.size.height).to_f32_px(), + None => extract_pixel_length(&ty), + }; + Transform3D::create_translation(0., ty, 0.) + } + ComputedOperation::TranslateZ(tz) => { + Transform3D::create_translation(0., 0., tz.to_f32_px()) + } ComputedOperation::Translate(tx, ty, tz) => { let (tx, ty) = match reference_box { Some(relative_border_box) => { From e74d04c0402407395ce30843be41b11080dbdf7f Mon Sep 17 00:00:00 2001 From: Manish Goregaokar Date: Mon, 11 Sep 2017 16:46:18 -0700 Subject: [PATCH 2/4] stylo: Preserve the variant of scale() values in computed transforms --- components/style/properties/gecko.mako.rs | 6 ++++++ .../helpers/animated_properties.mako.rs | 3 +++ .../style/properties/longhand/box.mako.rs | 21 ++++++++++++++++--- components/style/values/computed/transform.rs | 9 ++++++++ 4 files changed, 36 insertions(+), 3 deletions(-) diff --git a/components/style/properties/gecko.mako.rs b/components/style/properties/gecko.mako.rs index 38bb53e4df3..30d51e1b1e8 100644 --- a/components/style/properties/gecko.mako.rs +++ b/components/style/properties/gecko.mako.rs @@ -3073,6 +3073,9 @@ fn static_assert() { ${transform_function_arm("TranslateY", "translatey", ["lop"])} ${transform_function_arm("TranslateZ", "translatez", ["length"])} ${transform_function_arm("Translate", "translate3d", ["lop", "lop", "length"])} + ${transform_function_arm("ScaleX", "scalex", ["number"])} + ${transform_function_arm("ScaleY", "scaley", ["number"])} + ${transform_function_arm("ScaleZ", "scalez", ["number"])} ${transform_function_arm("Scale", "scale3d", ["number"] * 3)} ${transform_function_arm("Rotate", "rotate3d", ["number"] * 3 + ["angle"])} ${transform_function_arm("Perspective", "perspective", ["length"])} @@ -3197,6 +3200,9 @@ fn static_assert() { ${computed_operation_arm("TranslateY", "translatey", ["lop"])} ${computed_operation_arm("TranslateZ", "translatez", ["length"])} ${computed_operation_arm("Translate", "translate3d", ["lop", "lop", "length"])} + ${computed_operation_arm("ScaleX", "scalex", ["number"])} + ${computed_operation_arm("ScaleY", "scaley", ["number"])} + ${computed_operation_arm("ScaleZ", "scalez", ["number"])} ${computed_operation_arm("Scale", "scale3d", ["number"] * 3)} ${computed_operation_arm("Rotate", "rotate3d", ["number"] * 3 + ["angle"])} ${computed_operation_arm("Perspective", "perspective", ["length"])} diff --git a/components/style/properties/helpers/animated_properties.mako.rs b/components/style/properties/helpers/animated_properties.mako.rs index 1bdd06ef33a..0afe77246a9 100644 --- a/components/style/properties/helpers/animated_properties.mako.rs +++ b/components/style/properties/helpers/animated_properties.mako.rs @@ -1160,6 +1160,9 @@ impl ToAnimatedZero for TransformOperation { TransformOperation::Scale(..) => { Ok(TransformOperation::Scale(1.0, 1.0, 1.0)) }, + TransformOperation::ScaleX(_) => Ok(TransformOperation::ScaleX(1.)), + TransformOperation::ScaleY(_) => Ok(TransformOperation::ScaleY(1.)), + TransformOperation::ScaleZ(_) => Ok(TransformOperation::ScaleZ(1.)), TransformOperation::Rotate(x, y, z, a) => { let (x, y, z, _) = TransformList::get_normalized_vector_and_angle(x, y, z, a); Ok(TransformOperation::Rotate(x, y, z, Angle::zero())) diff --git a/components/style/properties/longhand/box.mako.rs b/components/style/properties/longhand/box.mako.rs index 03af3b83670..622b48c79fd 100644 --- a/components/style/properties/longhand/box.mako.rs +++ b/components/style/properties/longhand/box.mako.rs @@ -689,6 +689,9 @@ ${helpers.predefined_type( Translate(computed::LengthOrPercentage, computed::LengthOrPercentage, computed::Length), + ScaleX(CSSFloat), + ScaleY(CSSFloat), + ScaleZ(CSSFloat), Scale(CSSFloat, CSSFloat, CSSFloat), Rotate(CSSFloat, CSSFloat, CSSFloat, computed::Angle), Perspective(computed::Length), @@ -1292,15 +1295,15 @@ ${helpers.predefined_type( } SpecifiedOperation::ScaleX(sx) => { let sx = sx.to_computed_value(context); - result.push(computed_value::ComputedOperation::Scale(sx, 1.0, 1.0)); + result.push(computed_value::ComputedOperation::ScaleX(sx)); } SpecifiedOperation::ScaleY(sy) => { let sy = sy.to_computed_value(context); - result.push(computed_value::ComputedOperation::Scale(1.0, sy, 1.0)); + result.push(computed_value::ComputedOperation::ScaleY(sy)); } SpecifiedOperation::ScaleZ(sz) => { let sz = sz.to_computed_value(context); - result.push(computed_value::ComputedOperation::Scale(1.0, 1.0, sz)); + result.push(computed_value::ComputedOperation::ScaleZ(sz)); } SpecifiedOperation::Scale3D(sx, sy, sz) => { let sx = sx.to_computed_value(context); @@ -1435,6 +1438,18 @@ ${helpers.predefined_type( ToComputedValue::from_computed_value(ty), ToComputedValue::from_computed_value(tz))); } + computed_value::ComputedOperation::ScaleX(ref sx) => { + result.push(SpecifiedOperation::ScaleX( + ToComputedValue::from_computed_value(sx))); + } + computed_value::ComputedOperation::ScaleY(ref sy) => { + result.push(SpecifiedOperation::ScaleY( + ToComputedValue::from_computed_value(sy))); + } + computed_value::ComputedOperation::ScaleZ(ref sz) => { + result.push(SpecifiedOperation::ScaleZ( + ToComputedValue::from_computed_value(sz))); + } computed_value::ComputedOperation::Scale(ref sx, ref sy, ref sz) => { result.push(SpecifiedOperation::Scale3D( Number::from_computed_value(sx), diff --git a/components/style/values/computed/transform.rs b/components/style/values/computed/transform.rs index 88910e0ff63..8ec14a5fdad 100644 --- a/components/style/values/computed/transform.rs +++ b/components/style/values/computed/transform.rs @@ -89,6 +89,15 @@ impl TransformList { ComputedOperation::Perspective(d) => { Self::create_perspective_matrix(d.px()) } + ComputedOperation::ScaleX(sx) => { + Transform3D::create_scale(sx, 1., 1.) + } + ComputedOperation::ScaleY(sy) => { + Transform3D::create_scale(1., sy, 1.) + } + ComputedOperation::ScaleZ(sz) => { + Transform3D::create_scale(1., 1., sz) + } ComputedOperation::Scale(sx, sy, sz) => { Transform3D::create_scale(sx, sy, sz) } From 06300999e94f59efcaa76c1739b66da833c2f1f9 Mon Sep 17 00:00:00 2001 From: Manish Goregaokar Date: Mon, 11 Sep 2017 17:16:07 -0700 Subject: [PATCH 3/4] stylo: Preserve the variant of rotate() values in computed transforms MozReview-Commit-ID: Dmw7P21I6FN --- components/style/properties/gecko.mako.rs | 6 ++++++ .../helpers/animated_properties.mako.rs | 3 +++ .../style/properties/longhand/box.mako.rs | 21 ++++++++++++++++--- components/style/values/computed/transform.rs | 12 +++++++++++ 4 files changed, 39 insertions(+), 3 deletions(-) diff --git a/components/style/properties/gecko.mako.rs b/components/style/properties/gecko.mako.rs index 30d51e1b1e8..20768a31f47 100644 --- a/components/style/properties/gecko.mako.rs +++ b/components/style/properties/gecko.mako.rs @@ -3077,6 +3077,9 @@ fn static_assert() { ${transform_function_arm("ScaleY", "scaley", ["number"])} ${transform_function_arm("ScaleZ", "scalez", ["number"])} ${transform_function_arm("Scale", "scale3d", ["number"] * 3)} + ${transform_function_arm("RotateX", "rotatex", ["angle"])} + ${transform_function_arm("RotateY", "rotatey", ["angle"])} + ${transform_function_arm("RotateZ", "rotatez", ["angle"])} ${transform_function_arm("Rotate", "rotate3d", ["number"] * 3 + ["angle"])} ${transform_function_arm("Perspective", "perspective", ["length"])} ${transform_function_arm("InterpolateMatrix", "interpolatematrix", @@ -3204,6 +3207,9 @@ fn static_assert() { ${computed_operation_arm("ScaleY", "scaley", ["number"])} ${computed_operation_arm("ScaleZ", "scalez", ["number"])} ${computed_operation_arm("Scale", "scale3d", ["number"] * 3)} + ${computed_operation_arm("RotateX", "rotatex", ["angle"])} + ${computed_operation_arm("RotateY", "rotatey", ["angle"])} + ${computed_operation_arm("RotateZ", "rotatez", ["angle"])} ${computed_operation_arm("Rotate", "rotate3d", ["number"] * 3 + ["angle"])} ${computed_operation_arm("Perspective", "perspective", ["length"])} ${computed_operation_arm("InterpolateMatrix", "interpolatematrix", diff --git a/components/style/properties/helpers/animated_properties.mako.rs b/components/style/properties/helpers/animated_properties.mako.rs index 0afe77246a9..51f9d9c362e 100644 --- a/components/style/properties/helpers/animated_properties.mako.rs +++ b/components/style/properties/helpers/animated_properties.mako.rs @@ -1163,6 +1163,9 @@ impl ToAnimatedZero for TransformOperation { TransformOperation::ScaleX(_) => Ok(TransformOperation::ScaleX(1.)), TransformOperation::ScaleY(_) => Ok(TransformOperation::ScaleY(1.)), TransformOperation::ScaleZ(_) => Ok(TransformOperation::ScaleZ(1.)), + TransformOperation::RotateX(_) => Ok(TransformOperation::RotateX(Angle::zero())), + TransformOperation::RotateY(_) => Ok(TransformOperation::RotateY(Angle::zero())), + TransformOperation::RotateZ(_) => Ok(TransformOperation::RotateZ(Angle::zero())), TransformOperation::Rotate(x, y, z, a) => { let (x, y, z, _) = TransformList::get_normalized_vector_and_angle(x, y, z, a); Ok(TransformOperation::Rotate(x, y, z, Angle::zero())) diff --git a/components/style/properties/longhand/box.mako.rs b/components/style/properties/longhand/box.mako.rs index 622b48c79fd..44f42de0fa3 100644 --- a/components/style/properties/longhand/box.mako.rs +++ b/components/style/properties/longhand/box.mako.rs @@ -693,6 +693,9 @@ ${helpers.predefined_type( ScaleY(CSSFloat), ScaleZ(CSSFloat), Scale(CSSFloat, CSSFloat, CSSFloat), + RotateX(computed::Angle), + RotateY(computed::Angle), + RotateZ(computed::Angle), Rotate(CSSFloat, CSSFloat, CSSFloat, computed::Angle), Perspective(computed::Length), // For mismatched transform lists. @@ -1317,15 +1320,15 @@ ${helpers.predefined_type( } SpecifiedOperation::RotateX(theta) => { let theta = theta.to_computed_value(context); - result.push(computed_value::ComputedOperation::Rotate(1.0, 0.0, 0.0, theta)); + result.push(computed_value::ComputedOperation::RotateX(theta)); } SpecifiedOperation::RotateY(theta) => { let theta = theta.to_computed_value(context); - result.push(computed_value::ComputedOperation::Rotate(0.0, 1.0, 0.0, theta)); + result.push(computed_value::ComputedOperation::RotateY(theta)); } SpecifiedOperation::RotateZ(theta) => { let theta = theta.to_computed_value(context); - result.push(computed_value::ComputedOperation::Rotate(0.0, 0.0, 1.0, theta)); + result.push(computed_value::ComputedOperation::RotateZ(theta)); } SpecifiedOperation::Rotate3D(ax, ay, az, theta) => { let ax = ax.to_computed_value(context); @@ -1456,6 +1459,18 @@ ${helpers.predefined_type( Number::from_computed_value(sy), Number::from_computed_value(sz))); } + computed_value::ComputedOperation::RotateX(ref rx) => { + result.push(SpecifiedOperation::RotateX( + ToComputedValue::from_computed_value(rx))); + } + computed_value::ComputedOperation::RotateY(ref ry) => { + result.push(SpecifiedOperation::RotateY( + ToComputedValue::from_computed_value(ry))); + } + computed_value::ComputedOperation::RotateZ(ref rz) => { + result.push(SpecifiedOperation::RotateZ( + ToComputedValue::from_computed_value(rz))); + } computed_value::ComputedOperation::Rotate(ref ax, ref ay, ref az, ref theta) => { result.push(SpecifiedOperation::Rotate3D( Number::from_computed_value(ax), diff --git a/components/style/values/computed/transform.rs b/components/style/values/computed/transform.rs index 8ec14a5fdad..244055ba408 100644 --- a/components/style/values/computed/transform.rs +++ b/components/style/values/computed/transform.rs @@ -80,6 +80,18 @@ impl TransformList { for operation in list { let matrix = match *operation { + ComputedOperation::RotateX(theta) => { + let theta = Angle::from_radians(2.0f32 * f32::consts::PI - theta.radians()); + Transform3D::create_rotation(1., 0., 0., theta.into()) + } + ComputedOperation::RotateY(theta) => { + let theta = Angle::from_radians(2.0f32 * f32::consts::PI - theta.radians()); + Transform3D::create_rotation(0., 1., 0., theta.into()) + } + ComputedOperation::RotateZ(theta) => { + let theta = Angle::from_radians(2.0f32 * f32::consts::PI - theta.radians()); + Transform3D::create_rotation(0., 0., 1., theta.into()) + } ComputedOperation::Rotate(ax, ay, az, theta) => { let theta = Angle::from_radians(2.0f32 * f32::consts::PI - theta.radians()); let (ax, ay, az, theta) = From a7a5adb71a9da4b8682887a78082f57b3848786a Mon Sep 17 00:00:00 2001 From: Manish Goregaokar Date: Wed, 13 Sep 2017 15:37:52 -0700 Subject: [PATCH 4/4] stylo: Fix TransformOperation.animate() implementation --- .../helpers/animated_properties.mako.rs | 66 +++++++++++++++++++ components/style/values/computed/transform.rs | 2 +- 2 files changed, 67 insertions(+), 1 deletion(-) diff --git a/components/style/properties/helpers/animated_properties.mako.rs b/components/style/properties/helpers/animated_properties.mako.rs index 51f9d9c362e..df28b675db8 100644 --- a/components/style/properties/helpers/animated_properties.mako.rs +++ b/components/style/properties/helpers/animated_properties.mako.rs @@ -1230,6 +1230,30 @@ impl Animate for TransformOperation { fz.animate(tz, procedure)?, )) }, + ( + &TransformOperation::TranslateX(ref from), + &TransformOperation::TranslateX(ref to), + ) => { + Ok(TransformOperation::TranslateX( + from.animate(to, procedure)?, + )) + }, + ( + &TransformOperation::TranslateY(ref from), + &TransformOperation::TranslateY(ref to), + ) => { + Ok(TransformOperation::TranslateY( + from.animate(to, procedure)?, + )) + }, + ( + &TransformOperation::TranslateZ(ref from), + &TransformOperation::TranslateZ(ref to), + ) => { + Ok(TransformOperation::TranslateZ( + from.animate(to, procedure)?, + )) + }, ( &TransformOperation::Scale(ref fx, ref fy, ref fz), &TransformOperation::Scale(ref tx, ref ty, ref tz), @@ -1240,6 +1264,48 @@ impl Animate for TransformOperation { animate_multiplicative_factor(*fz, *tz, procedure)?, )) }, + ( + &TransformOperation::ScaleX(ref from), + &TransformOperation::ScaleX(ref to), + ) => { + Ok(TransformOperation::ScaleX( + animate_multiplicative_factor(*from, *to, procedure)?, + )) + }, + ( + &TransformOperation::ScaleY(ref from), + &TransformOperation::ScaleY(ref to), + ) => { + Ok(TransformOperation::ScaleY( + animate_multiplicative_factor(*from, *to, procedure)?, + )) + }, + ( + &TransformOperation::ScaleZ(ref from), + &TransformOperation::ScaleZ(ref to), + ) => { + Ok(TransformOperation::ScaleZ( + animate_multiplicative_factor(*from, *to, procedure)?, + )) + }, + ( + &TransformOperation::RotateX(ref from), + &TransformOperation::RotateX(ref to), + ) => { + Ok(TransformOperation::RotateX(from.animate(to, procedure)?)) + }, + ( + &TransformOperation::RotateY(ref from), + &TransformOperation::RotateY(ref to), + ) => { + Ok(TransformOperation::RotateY(from.animate(to, procedure)?)) + }, + ( + &TransformOperation::RotateZ(ref from), + &TransformOperation::RotateZ(ref to), + ) => { + Ok(TransformOperation::RotateZ(from.animate(to, procedure)?)) + }, ( &TransformOperation::Rotate(fx, fy, fz, fa), &TransformOperation::Rotate(tx, ty, tz, ta), diff --git a/components/style/values/computed/transform.rs b/components/style/values/computed/transform.rs index 244055ba408..90d9459e700 100644 --- a/components/style/values/computed/transform.rs +++ b/components/style/values/computed/transform.rs @@ -128,7 +128,7 @@ impl TransformList { Transform3D::create_translation(0., ty, 0.) } ComputedOperation::TranslateZ(tz) => { - Transform3D::create_translation(0., 0., tz.to_f32_px()) + Transform3D::create_translation(0., 0., tz.px()) } ComputedOperation::Translate(tx, ty, tz) => { let (tx, ty) = match reference_box {