Derive ToCss for MozImageRect

components/style/values/computed/image.rs

@@ -17,7 +17,7 @@ use values::computed::position::Position;
 use values::generics::image::{CompatMode, ColorStop as GenericColorStop, EndingShape as GenericEndingShape};
 use values::generics::image::{Gradient as GenericGradient, GradientItem as GenericGradientItem};
 use values::generics::image::{Image as GenericImage, GradientKind as GenericGradientKind};
-use values::generics::image::{ImageRect as GenericImageRect, LineDirection as GenericLineDirection};
+use values::generics::image::{LineDirection as GenericLineDirection, MozImageRect as GenericMozImageRect};
 use values::specified::image::LineDirection as SpecifiedLineDirection;
 use values::specified::position::{X, Y};
 
@@ -26,7 +26,7 @@ pub type ImageLayer = Either<None_, Image>;
 
 /// Computed values for an image according to CSS-IMAGES.
 /// https://drafts.csswg.org/css-images/#image-values
-pub type Image = GenericImage<Gradient, ImageRect>;
+pub type Image = GenericImage<Gradient, MozImageRect>;
 
 /// Computed values for a CSS gradient.
 /// https://drafts.csswg.org/css-images/#gradients
@@ -65,8 +65,8 @@ pub type GradientItem = GenericGradientItem<RGBA, LengthOrPercentage>;
 /// A computed color stop.
 pub type ColorStop = GenericColorStop<RGBA, LengthOrPercentage>;
 
-/// Computed values for ImageRect.
-pub type ImageRect = GenericImageRect<NumberOrPercentage>;
+/// Computed values for MozImageRect.
+pub type MozImageRect = GenericMozImageRect<NumberOrPercentage>;
 
 impl GenericLineDirection for LineDirection {
     fn points_downwards(&self) -> bool {

components/style/values/computed/mod.rs

@@ -28,7 +28,7 @@ pub use self::background::BackgroundSize;
 pub use self::border::{BorderImageSlice, BorderImageWidth, BorderImageSideWidth};
 pub use self::border::{BorderRadius, BorderCornerRadius};
 pub use self::color::{Color, RGBAColor};
-pub use self::image::{Gradient, GradientItem, ImageLayer, LineDirection, Image, ImageRect};
+pub use self::image::{Gradient, GradientItem, ImageLayer, LineDirection, Image, MozImageRect};
 #[cfg(feature = "gecko")]
 pub use self::gecko::ScrollSnapPoint;
 pub use self::rect::LengthOrNumberRect;

components/style/values/generics/image.rs

@@ -18,13 +18,13 @@ use values::specified::url::SpecifiedUrl;
 /// [image]: https://drafts.csswg.org/css-images/#image-values
 #[derive(Clone, PartialEq, ToComputedValue)]
 #[cfg_attr(feature = "servo", derive(HeapSizeOf))]
-pub enum Image<Gradient, ImageRect> {
+pub enum Image<Gradient, MozImageRect> {
     /// A `<url()>` image.
     Url(SpecifiedUrl),
     /// A `<gradient>` image.
     Gradient(Gradient),
     /// A `-moz-image-rect` image
-    Rect(ImageRect),
+    Rect(MozImageRect),
     /// A `-moz-element(# <element-id>)`
     Element(Atom),
     /// A paint worklet image.
@@ -151,11 +151,12 @@ impl ToCss for PaintWorklet {
 
 /// Values for `moz-image-rect`.
 ///
-/// `-moz-image-rect(<uri>, top, right, bottom, left);`
-#[derive(Clone, Debug, PartialEq, ToComputedValue)]
-#[cfg_attr(feature = "servo", derive(HeapSizeOf))]
+/// `-moz-image-rect(<uri>, top, right, bottom, left)`
 #[allow(missing_docs)]
-pub struct ImageRect<NumberOrPercentage> {
+#[cfg_attr(feature = "servo", derive(HeapSizeOf))]
+#[css(function)]
+#[derive(Clone, Debug, PartialEq, ToComputedValue, ToCss)]
+pub struct MozImageRect<NumberOrPercentage> {
     pub url: SpecifiedUrl,
     pub top: NumberOrPercentage,
     pub bottom: NumberOrPercentage,
@@ -337,21 +338,3 @@ impl<C, L> ToCss for ColorStop<C, L>
         Ok(())
     }
 }
-
-impl<C> ToCss for ImageRect<C>
-    where C: ToCss,
-{
-    fn to_css<W>(&self, dest: &mut W) -> fmt::Result where W: fmt::Write {
-        dest.write_str("-moz-image-rect(")?;
-        self.url.to_css(dest)?;
-        dest.write_str(", ")?;
-        self.top.to_css(dest)?;
-        dest.write_str(", ")?;
-        self.right.to_css(dest)?;
-        dest.write_str(", ")?;
-        self.bottom.to_css(dest)?;
-        dest.write_str(", ")?;
-        self.left.to_css(dest)?;
-        dest.write_str(")")
-    }
-}

components/style/values/specified/image.rs

@@ -21,9 +21,8 @@ use values::{Either, None_};
 use values::generics::image::{Circle, CompatMode, Ellipse, ColorStop as GenericColorStop};
 use values::generics::image::{EndingShape as GenericEndingShape, Gradient as GenericGradient};
 use values::generics::image::{GradientItem as GenericGradientItem, GradientKind as GenericGradientKind};
-use values::generics::image::{Image as GenericImage, ImageRect as GenericImageRect};
-use values::generics::image::{LineDirection as GenericsLineDirection, ShapeExtent};
-use values::generics::image::PaintWorklet;
+use values::generics::image::{Image as GenericImage, LineDirection as GenericsLineDirection};
+use values::generics::image::{MozImageRect as GenericMozImageRect, PaintWorklet, ShapeExtent};
 use values::generics::position::Position as GenericPosition;
 use values::specified::{Angle, Color, Length, LengthOrPercentage};
 use values::specified::{Number, NumberOrPercentage, Percentage, RGBAColor};
@@ -35,7 +34,7 @@ pub type ImageLayer = Either<None_, Image>;
 
 /// Specified values for an image according to CSS-IMAGES.
 /// https://drafts.csswg.org/css-images/#image-values
-pub type Image = GenericImage<Gradient, ImageRect>;
+pub type Image = GenericImage<Gradient, MozImageRect>;
 
 /// Specified values for a CSS gradient.
 /// https://drafts.csswg.org/css-images/#gradients
@@ -80,7 +79,7 @@ pub type ColorStop = GenericColorStop<RGBAColor, LengthOrPercentage>;
 
 /// Specified values for `moz-image-rect`
 /// -moz-image-rect(<uri>, top, right, bottom, left);
-pub type ImageRect = GenericImageRect<NumberOrPercentage>;
+pub type MozImageRect = GenericMozImageRect<NumberOrPercentage>;
 
 impl Parse for Image {
     fn parse<'i, 't>(context: &ParserContext, input: &mut Parser<'i, 't>) -> Result<Image, ParseError<'i>> {
@@ -108,14 +107,14 @@ impl Parse for Image {
         }
         #[cfg(feature = "gecko")]
         {
-            if let Ok(mut image_rect) = input.try(|input| ImageRect::parse(context, input)) {
+            if let Ok(mut image_rect) = input.try(|input| MozImageRect::parse(context, input)) {
                 image_rect.url.build_image_value();
                 return Ok(GenericImage::Rect(image_rect));
             }
         }
         #[cfg(feature = "servo")]
         {
-            if let Ok(image_rect) = input.try(|input| ImageRect::parse(context, input)) {
+            if let Ok(image_rect) = input.try(|input| MozImageRect::parse(context, input)) {
                 return Ok(GenericImage::Rect(image_rect));
             }
         }
@@ -705,7 +704,7 @@ impl Parse for PaintWorklet {
     }
 }
 
-impl Parse for ImageRect {
+impl Parse for MozImageRect {
     fn parse<'i, 't>(context: &ParserContext, input: &mut Parser<'i, 't>) -> Result<Self, ParseError<'i>> {
         input.try(|i| i.expect_function_matching("-moz-image-rect"))?;
         input.parse_nested_block(|i| {
@@ -720,7 +719,7 @@ impl Parse for ImageRect {
             i.expect_comma()?;
             let left = NumberOrPercentage::parse_non_negative(context, i)?;
 
-            Ok(ImageRect {
+            Ok(MozImageRect {
                 url: url,
                 top: top,
                 right: right,

components/style/values/specified/mod.rs

@@ -36,7 +36,7 @@ pub use self::rect::LengthOrNumberRect;
 #[cfg(feature = "gecko")]
 pub use self::gecko::ScrollSnapPoint;
 pub use self::image::{ColorStop, EndingShape as GradientEndingShape, Gradient};
-pub use self::image::{GradientItem, GradientKind, Image, ImageRect, ImageLayer};
+pub use self::image::{GradientItem, GradientKind, Image, MozImageRect, ImageLayer};
 pub use self::length::AbsoluteLength;
 pub use self::length::{FontRelativeLength, ViewportPercentageLength, CharacterWidth, Length, CalcLengthOrPercentage};
 pub use self::length::{Percentage, LengthOrNone, LengthOrNumber, LengthOrPercentage, LengthOrPercentageOrAuto};