style: Implement css(dimension) and derive ToCss for a bunch of stuff.

For css(dimension), it'd be nice to derive(Parse) too, I think...

components/style/values/specified/angle.rs

@@ -57,12 +57,12 @@ impl ToComputedValue for Angle {
 impl Angle {
     /// Creates an angle with the given value in degrees.
     pub fn from_degrees(value: CSSFloat, was_calc: bool) -> Self {
-        Angle { value: ComputedAngle::Degree(value), was_calc }
+        Angle { value: ComputedAngle::Deg(value), was_calc }
     }
 
     /// Creates an angle with the given value in gradians.
     pub fn from_gradians(value: CSSFloat, was_calc: bool) -> Self {
-        Angle { value: ComputedAngle::Gradian(value), was_calc }
+        Angle { value: ComputedAngle::Grad(value), was_calc }
     }
 
     /// Creates an angle with the given value in turns.
@@ -72,7 +72,7 @@ impl Angle {
 
     /// Creates an angle with the given value in radians.
     pub fn from_radians(value: CSSFloat, was_calc: bool) -> Self {
-        Angle { value: ComputedAngle::Radian(value), was_calc }
+        Angle { value: ComputedAngle::Rad(value), was_calc }
     }
 
     /// Returns the amount of radians this angle represents.
@@ -89,7 +89,7 @@ impl Angle {
     /// Returns an `Angle` parsed from a `calc()` expression.
     pub fn from_calc(radians: CSSFloat) -> Self {
         Angle {
-            value: ComputedAngle::Radian(radians),
+            value: ComputedAngle::Rad(radians),
             was_calc: true,
         }
     }

components/style/values/specified/calc.rs

@@ -400,7 +400,13 @@ impl CalcNode {
                     NoCalcLength::ServoCharacterWidth(..) => unreachable!(),
                     #[cfg(feature = "gecko")]
                     NoCalcLength::Physical(physical) => {
-                        ret.mozmm = Some(ret.mozmm.unwrap_or(0.) + physical.0 * factor);
+                        use values::specified::length::PhysicalLength;
+
+                        match physical {
+                            PhysicalLength::Mozmm(mozmm) => {
+                                ret.mozmm = Some(ret.mozmm.unwrap_or(0.) + mozmm * factor);
+                            }
+                        }
                     }
                 }
             }

components/style/values/specified/length.rs

@@ -11,15 +11,14 @@ use cssparser::{Parser, Token};
 use euclid::Size2D;
 use font_metrics::FontMetricsQueryResult;
 use parser::{Parse, ParserContext};
-use std::{cmp, fmt, mem};
+use std::{cmp, mem};
 #[allow(unused_imports)] use std::ascii::AsciiExt;
 use std::ops::{Add, Mul};
-use style_traits::{ToCss, ParseError, StyleParseErrorKind};
+use style_traits::{ParseError, StyleParseErrorKind};
 use style_traits::values::specified::AllowedNumericType;
 use stylesheets::CssRuleType;
 use super::{AllowQuirks, Number, ToComputedValue, Percentage};
-use values::{Auto, CSSFloat, Either, None_, Normal};
-use values::{ExtremumLength, serialize_dimension};
+use values::{Auto, CSSFloat, Either, ExtremumLength, None_, Normal};
 use values::computed::{self, CSSPixelLength, Context};
 use values::generics::NonNegative;
 use values::specified::NonNegativeNumber;
@@ -52,8 +51,9 @@ pub fn au_to_int_px(au: f32) -> i32 {
     (au / AU_PER_PX).round() as i32
 }
 
-#[derive(Clone, Copy, Debug, MallocSizeOf, PartialEq)]
 /// A font relative length.
+#[derive(Clone, Copy, Debug, MallocSizeOf, PartialEq, ToCss)]
+#[css(dimension)]
 pub enum FontRelativeLength {
     /// A "em" value: https://drafts.csswg.org/css-values/#em
     Em(CSSFloat),
@@ -65,19 +65,6 @@ pub enum FontRelativeLength {
     Rem(CSSFloat)
 }
 
-impl ToCss for FontRelativeLength {
-    fn to_css<W>(&self, dest: &mut W) -> fmt::Result
-        where W: fmt::Write
-    {
-        match *self {
-            FontRelativeLength::Em(length) => serialize_dimension(length, "em", dest),
-            FontRelativeLength::Ex(length) => serialize_dimension(length, "ex", dest),
-            FontRelativeLength::Ch(length) => serialize_dimension(length, "ch", dest),
-            FontRelativeLength::Rem(length) => serialize_dimension(length, "rem", dest)
-        }
-    }
-}
-
 /// A source to resolve font-relative units against
 #[derive(Clone, Copy, Debug, PartialEq)]
 pub enum FontBaseSize {
@@ -206,10 +193,11 @@ impl FontRelativeLength {
     }
 }
 
-#[derive(Clone, Copy, Debug, MallocSizeOf, PartialEq)]
 /// A viewport-relative length.
 ///
 /// <https://drafts.csswg.org/css-values/#viewport-relative-lengths>
+#[derive(Clone, Copy, Debug, MallocSizeOf, PartialEq, ToCss)]
+#[css(dimension)]
 pub enum ViewportPercentageLength {
     /// A vw unit: https://drafts.csswg.org/css-values/#vw
     Vw(CSSFloat),
@@ -221,17 +209,6 @@ pub enum ViewportPercentageLength {
     Vmax(CSSFloat)
 }
 
-impl ToCss for ViewportPercentageLength {
-    fn to_css<W>(&self, dest: &mut W) -> fmt::Result where W: fmt::Write {
-        match *self {
-            ViewportPercentageLength::Vw(length) => serialize_dimension(length, "vw", dest),
-            ViewportPercentageLength::Vh(length) => serialize_dimension(length, "vh", dest),
-            ViewportPercentageLength::Vmin(length) => serialize_dimension(length, "vmin", dest),
-            ViewportPercentageLength::Vmax(length) => serialize_dimension(length, "vmax", dest)
-        }
-    }
-}
-
 impl ViewportPercentageLength {
     /// Computes the given viewport-relative length for the given viewport size.
     pub fn to_computed_value(&self, viewport_size: Size2D<Au>) -> CSSPixelLength {
@@ -255,7 +232,7 @@ impl ViewportPercentageLength {
 }
 
 /// HTML5 "character width", as defined in HTML5 § 14.5.4.
-#[derive(Clone, Copy, Debug, MallocSizeOf, PartialEq)]
+#[derive(Clone, Copy, Debug, MallocSizeOf, PartialEq, ToCss)]
 pub struct CharacterWidth(pub i32);
 
 impl CharacterWidth {
@@ -273,7 +250,8 @@ impl CharacterWidth {
 }
 
 /// Represents an absolute length with its unit
-#[derive(Clone, Copy, Debug, MallocSizeOf, PartialEq)]
+#[derive(Clone, Copy, Debug, MallocSizeOf, PartialEq, ToCss)]
+#[css(dimension)]
 pub enum AbsoluteLength {
     /// An absolute length in pixels (px)
     Px(CSSFloat),
@@ -334,20 +312,6 @@ impl ToComputedValue for AbsoluteLength {
     }
 }
 
-impl ToCss for AbsoluteLength {
-    fn to_css<W>(&self, dest: &mut W) -> fmt::Result where W: fmt::Write {
-        match *self {
-            AbsoluteLength::Px(length) => serialize_dimension(length, "px", dest),
-            AbsoluteLength::In(length) => serialize_dimension(length, "in", dest),
-            AbsoluteLength::Cm(length) => serialize_dimension(length, "cm", dest),
-            AbsoluteLength::Mm(length) => serialize_dimension(length, "mm", dest),
-            AbsoluteLength::Q(length) => serialize_dimension(length, "q", dest),
-            AbsoluteLength::Pt(length) => serialize_dimension(length, "pt", dest),
-            AbsoluteLength::Pc(length) => serialize_dimension(length, "pc", dest),
-        }
-    }
-}
-
 impl Mul<CSSFloat> for AbsoluteLength {
     type Output = AbsoluteLength;
 
@@ -383,19 +347,25 @@ impl Add<AbsoluteLength> for AbsoluteLength {
     }
 }
 
-/// Represents a physical length (mozmm) based on DPI
-#[derive(Clone, Copy, Debug, PartialEq)]
-#[cfg(feature = "gecko")]
+/// Represents a physical length based on DPI.
+#[derive(Clone, Copy, Debug, PartialEq, ToCss)]
 #[derive(MallocSizeOf)]
-pub struct PhysicalLength(pub CSSFloat);
+#[css(dimension)]
+pub enum PhysicalLength {
+    /// A physical length in millimetres.
+    Mozmm(CSSFloat),
+}
 
-#[cfg(feature = "gecko")]
 impl PhysicalLength {
-    fn is_zero(&self) -> bool {
-        self.0 == 0.
+    /// Checks whether the length value is zero.
+    pub fn is_zero(&self) -> bool {
+        match *self {
+            PhysicalLength::Mozmm(v) => v == 0.,
+        }
     }
 
     /// Computes the given character width.
+    #[cfg(feature = "gecko")]
     pub fn to_computed_value(&self, context: &Context) -> CSSPixelLength {
         use gecko_bindings::bindings;
         use std::f32;
@@ -408,32 +378,31 @@ impl PhysicalLength {
         };
 
         let px_per_physical_inch = au_per_physical_inch / AU_PER_PX;
-        let pixel = self.0 * px_per_physical_inch * INCH_PER_MM;
+
+        let mm = match *self {
+            PhysicalLength::Mozmm(v) => v,
+        };
+
+        let pixel = mm * px_per_physical_inch * INCH_PER_MM;
         CSSPixelLength::new(pixel.min(f32::MAX).max(f32::MIN))
     }
 }
 
-#[cfg(feature = "gecko")]
-impl ToCss for PhysicalLength {
-    fn to_css<W>(&self, dest: &mut W) -> fmt::Result where W: fmt::Write {
-        serialize_dimension(self.0, "mozmm", dest)
-    }
-}
-
-#[cfg(feature = "gecko")]
 impl Mul<CSSFloat> for PhysicalLength {
-    type Output = PhysicalLength;
+    type Output = Self ;
 
     #[inline]
-    fn mul(self, scalar: CSSFloat) -> PhysicalLength {
-        PhysicalLength(self.0 * scalar)
+    fn mul(self, scalar: CSSFloat) -> Self {
+        match self {
+            PhysicalLength::Mozmm(v) => PhysicalLength::Mozmm(v * scalar),
+        }
     }
 }
 
 /// A `<length>` without taking `calc` expressions into account
 ///
 /// <https://drafts.csswg.org/css-values/#lengths>
-#[derive(Clone, Copy, Debug, MallocSizeOf, PartialEq)]
+#[derive(Clone, Copy, Debug, MallocSizeOf, PartialEq, ToCss)]
 pub enum NoCalcLength {
     /// An absolute length
     ///
@@ -454,6 +423,7 @@ pub enum NoCalcLength {
     ///
     /// This cannot be specified by the user directly and is only generated by
     /// `Stylist::synthesize_rules_for_legacy_attributes()`.
+    #[css(function)]
     ServoCharacterWidth(CharacterWidth),
 
     /// A physical length (mozmm) based on DPI
@@ -461,24 +431,6 @@ pub enum NoCalcLength {
     Physical(PhysicalLength),
 }
 
-impl ToCss for NoCalcLength {
-    fn to_css<W>(&self, dest: &mut W) -> fmt::Result where W: fmt::Write {
-        match *self {
-            NoCalcLength::Absolute(length) => length.to_css(dest),
-            NoCalcLength::FontRelative(length) => length.to_css(dest),
-            NoCalcLength::ViewportPercentage(length) => length.to_css(dest),
-            /* This should only be reached from style dumping code */
-            NoCalcLength::ServoCharacterWidth(CharacterWidth(i)) => {
-                dest.write_str("CharWidth(")?;
-                i.to_css(dest)?;
-                dest.write_char(')')
-            }
-            #[cfg(feature = "gecko")]
-            NoCalcLength::Physical(length) => length.to_css(dest),
-        }
-    }
-}
-
 impl Mul<CSSFloat> for NoCalcLength {
     type Output = NoCalcLength;
 
@@ -539,7 +491,7 @@ impl NoCalcLength {
                 Ok(NoCalcLength::ViewportPercentage(ViewportPercentageLength::Vmax(value)))
             },
             #[cfg(feature = "gecko")]
-            "mozmm" => Ok(NoCalcLength::Physical(PhysicalLength(value))),
+            "mozmm" => Ok(NoCalcLength::Physical(PhysicalLength::Mozmm(value))),
             _ => Err(())
         }
     }