From dcefcc3c225e92c397fe04b42c75c94e94092397 Mon Sep 17 00:00:00 2001 From: Manish Goregaokar Date: Tue, 3 Oct 2017 15:06:44 -0700 Subject: [PATCH] Add ToComputedValue and ToCss impls --- components/style/values/generics/transform.rs | 158 +++++++++++++++++- components/style_derive/to_computed_value.rs | 5 +- 2 files changed, 153 insertions(+), 10 deletions(-) diff --git a/components/style/values/generics/transform.rs b/components/style/values/generics/transform.rs index 475924921be..56d3643404d 100644 --- a/components/style/values/generics/transform.rs +++ b/components/style/values/generics/transform.rs @@ -6,7 +6,7 @@ use std::fmt; use style_traits::ToCss; -use values::{computed, specified, CSSFloat}; +use values::{computed, CSSFloat}; /// A generic 2D transformation matrix. #[allow(missing_docs)] @@ -141,8 +141,9 @@ impl TimingKeyword { #[derive(Clone, Debug, PartialEq)] #[cfg_attr(feature = "gecko", derive(MallocSizeOf))] #[cfg_attr(feature = "servo", derive(HeapSizeOf))] +#[derive(ToComputedValue)] /// A single operation in the list of a `transform` value -pub enum TransformOperation { +pub enum TransformOperation { /// Represents a 2D 2x3 matrix. Matrix(Matrix), /// Represents a 3D 4x4 matrix with percentage and length values. @@ -222,21 +223,160 @@ pub enum TransformOperation>, - to_list: Transform>, - progress: computed::Percentage }, + InterpolateMatrix { #[compute(ignore_bound)] + from_list: Transform>, + #[compute(ignore_bound)] + to_list: Transform>, + #[compute(clone)] progress: computed::Percentage }, /// A intermediate type for accumulation of mismatched transform lists. #[allow(missing_docs)] - AccumulateMatrix { from_list: Transform>, - to_list: Transform>, - count: specified::Integer }, + + AccumulateMatrix { #[compute(ignore_bound)] + from_list: Transform>, + #[compute(ignore_bound)] + to_list: Transform>, + count: Integer }, } +#[derive(Animate, ToComputedValue)] #[derive(Clone, Debug, PartialEq)] #[cfg_attr(feature = "gecko", derive(MallocSizeOf))] #[cfg_attr(feature = "servo", derive(HeapSizeOf))] /// A value of the `transform` property pub struct Transform(Vec); + + +impl + ToCss for + TransformOperation { + fn to_css(&self, dest: &mut W) -> fmt::Result where W: fmt::Write { + match *self { + TransformOperation::Matrix(ref m) => m.to_css(dest), + TransformOperation::PrefixedMatrix(ref m) => m.to_css(dest), + TransformOperation::Matrix3D { + m11, m12, m13, m14, + m21, m22, m23, m24, + m31, m32, m33, m34, + m41, m42, m43, m44, + } => { + serialize_function!(dest, matrix3d( + m11, m12, m13, m14, + m21, m22, m23, m24, + m31, m32, m33, m34, + m41, m42, m43, m44, + )) + } + TransformOperation::PrefixedMatrix3D { + m11, m12, m13, m14, + m21, m22, m23, m24, + m31, m32, m33, m34, + ref m41, ref m42, ref m43, m44, + } => { + serialize_function!(dest, matrix3d( + m11, m12, m13, m14, + m21, m22, m23, m24, + m31, m32, m33, m34, + m41, m42, m43, m44, + )) + } + TransformOperation::Skew(ax, None) => { + serialize_function!(dest, skew(ax)) + } + TransformOperation::Skew(ax, Some(ay)) => { + serialize_function!(dest, skew(ax, ay)) + } + TransformOperation::SkewX(angle) => { + serialize_function!(dest, skewX(angle)) + } + TransformOperation::SkewY(angle) => { + serialize_function!(dest, skewY(angle)) + } + TransformOperation::Translate(ref tx, None) => { + serialize_function!(dest, translate(tx)) + } + TransformOperation::Translate(ref tx, Some(ref ty)) => { + serialize_function!(dest, translate(tx, ty)) + } + TransformOperation::TranslateX(ref tx) => { + serialize_function!(dest, translateX(tx)) + } + TransformOperation::TranslateY(ref ty) => { + serialize_function!(dest, translateY(ty)) + } + TransformOperation::TranslateZ(ref tz) => { + serialize_function!(dest, translateZ(tz)) + } + TransformOperation::Translate3D(ref tx, ref ty, ref tz) => { + serialize_function!(dest, translate3d(tx, ty, tz)) + } + TransformOperation::Scale(factor, None) => { + serialize_function!(dest, scale(factor)) + } + TransformOperation::Scale(sx, Some(sy)) => { + serialize_function!(dest, scale(sx, sy)) + } + TransformOperation::ScaleX(sx) => { + serialize_function!(dest, scaleX(sx)) + } + TransformOperation::ScaleY(sy) => { + serialize_function!(dest, scaleY(sy)) + } + TransformOperation::ScaleZ(sz) => { + serialize_function!(dest, scaleZ(sz)) + } + TransformOperation::Scale3D(sx, sy, sz) => { + serialize_function!(dest, scale3d(sx, sy, sz)) + } + TransformOperation::Rotate(theta) => { + serialize_function!(dest, rotate(theta)) + } + TransformOperation::RotateX(theta) => { + serialize_function!(dest, rotateX(theta)) + } + TransformOperation::RotateY(theta) => { + serialize_function!(dest, rotateY(theta)) + } + TransformOperation::RotateZ(theta) => { + serialize_function!(dest, rotateZ(theta)) + } + TransformOperation::Rotate3D(x, y, z, theta) => { + serialize_function!(dest, rotate3d(x, y, z, theta)) + } + TransformOperation::Perspective(ref length) => { + serialize_function!(dest, perspective(length)) + } + TransformOperation::InterpolateMatrix { ref from_list, ref to_list, progress } => { + serialize_function!(dest, interpolatematrix(from_list, to_list, progress)) + } + TransformOperation::AccumulateMatrix { ref from_list, ref to_list, count } => { + serialize_function!(dest, accumulatematrix(from_list, to_list, count)) + } + } + } +} + +impl ToCss for Transform { + fn to_css(&self, dest: &mut W) -> fmt::Result where W: fmt::Write { + if self.0.is_empty() { + return dest.write_str("none") + } + + let mut first = true; + for operation in &self.0 { + if !first { + dest.write_str(" ")?; + } + first = false; + operation.to_css(dest)? + } + Ok(()) + } +} diff --git a/components/style_derive/to_computed_value.rs b/components/style_derive/to_computed_value.rs index 7e4db276edd..c53b25408e9 100644 --- a/components/style_derive/to_computed_value.rs +++ b/components/style_derive/to_computed_value.rs @@ -25,7 +25,9 @@ pub fn derive(input: DeriveInput) -> Tokens { } quote! { ::std::clone::Clone::clone(#binding) } } else { - where_clause.add_trait_bound(&binding.field.ty); + if !attrs.ignore_bound { + where_clause.add_trait_bound(&binding.field.ty); + } quote! { ::values::computed::ToComputedValue::to_computed_value(#binding, context) } @@ -68,4 +70,5 @@ pub fn derive(input: DeriveInput) -> Tokens { #[derive(Default, FromField)] struct ComputedValueAttrs { clone: bool, + ignore_bound: bool, }