Refactor Brush to use generic types for image and gradient data (#134)

As discussed in
#133 (review)
we can also generalize `Brush` over image data and gradient. This makes
`BrushRef<'a> = Brush<ImageBrushRef<'a>, &'a Gradient>` which allows to
share more From impls, most notably various color implementations (even
owned version can now support conversion from &color because color is
copy anyway).

---------

Signed-off-by: sagudev <[email protected]>

Author: sagudev

src/brush.rs

@@ -10,48 +10,66 @@ use color::{AlphaColor, ColorSpace, DynamicColor, OpaqueColor, Srgb};
 /// Describes the color content of a filled or stroked shape.
 ///
 /// See also [`BrushRef`] which can be used to avoid allocations.
-#[derive(Clone, Debug, PartialEq)]
+#[derive(Copy, Clone, Debug, PartialEq)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
-pub enum Brush {
+pub enum Brush<I = ImageBrush, G = Gradient> {
     /// Solid color brush.
     Solid(AlphaColor<Srgb>),
     /// Gradient brush.
-    Gradient(Gradient),
+    Gradient(G),
     /// Image brush.
-    Image(ImageBrush),
+    Image(I),
 }
 
-impl<CS: ColorSpace> From<AlphaColor<CS>> for Brush {
+impl<CS: ColorSpace, I, G> From<AlphaColor<CS>> for Brush<I, G> {
     fn from(c: AlphaColor<CS>) -> Self {
         Self::Solid(c.convert())
     }
 }
 
-impl From<DynamicColor> for Brush {
+impl<I, G> From<DynamicColor> for Brush<I, G> {
     fn from(c: DynamicColor) -> Self {
         Self::Solid(c.to_alpha_color::<Srgb>())
     }
 }
 
-impl<CS: ColorSpace> From<OpaqueColor<CS>> for Brush {
+impl<CS: ColorSpace, I, G> From<OpaqueColor<CS>> for Brush<I, G> {
     fn from(c: OpaqueColor<CS>) -> Self {
         Self::Solid(c.with_alpha(1.).convert())
     }
 }
 
-impl From<Gradient> for Brush {
+impl<CS: ColorSpace, I, G> From<&AlphaColor<CS>> for Brush<I, G> {
+    fn from(c: &AlphaColor<CS>) -> Self {
+        Self::Solid((*c).convert())
+    }
+}
+
+impl<I, G> From<&DynamicColor> for Brush<I, G> {
+    fn from(c: &DynamicColor) -> Self {
+        Self::Solid((*c).to_alpha_color::<Srgb>())
+    }
+}
+
+impl<CS: ColorSpace, I, G> From<&OpaqueColor<CS>> for Brush<I, G> {
+    fn from(c: &OpaqueColor<CS>) -> Self {
+        Self::Solid((*c).with_alpha(1.).convert())
+    }
+}
+
+impl<I> From<Gradient> for Brush<I, Gradient> {
     fn from(g: Gradient) -> Self {
         Self::Gradient(g)
     }
 }
 
-impl From<ImageBrush> for Brush {
-    fn from(value: ImageBrush) -> Self {
+impl<G, D> From<ImageBrush<D>> for Brush<ImageBrush<D>, G> {
+    fn from(value: ImageBrush<D>) -> Self {
         Self::Image(value)
     }
 }
 
-impl Default for Brush {
+impl<I, G> Default for Brush<I, G> {
     fn default() -> Self {
         Self::Solid(AlphaColor::<Srgb>::TRANSPARENT)
     }
@@ -95,17 +113,9 @@ impl Brush {
 /// Reference to a [brush](Brush).
 ///
 /// This is useful for methods that would like to accept brushes by reference. Defining
-/// the type as `impl<Into<BrushRef>>` allows accepting types like `&LinearGradient`
+/// the type as `impl Into<BrushRef>` allows accepting types like `&Gradient`
 /// directly without cloning or allocating.
-#[derive(Copy, Clone, Debug, PartialEq)]
-pub enum BrushRef<'a> {
-    /// Solid color brush.
-    Solid(AlphaColor<Srgb>),
-    /// Gradient brush.
-    Gradient(&'a Gradient),
-    /// Image brush.
-    Image(ImageBrushRef<'a>),
-}
+pub type BrushRef<'a> = Brush<ImageBrushRef<'a>, &'a Gradient>;
 
 impl BrushRef<'_> {
     /// Converts the reference to an owned brush.
@@ -119,54 +129,12 @@ impl BrushRef<'_> {
     }
 }
 
-impl<CS: ColorSpace> From<AlphaColor<CS>> for BrushRef<'_> {
-    fn from(color: AlphaColor<CS>) -> Self {
-        Self::Solid(color.convert())
-    }
-}
-
-impl From<DynamicColor> for BrushRef<'_> {
-    fn from(color: DynamicColor) -> Self {
-        Self::Solid(color.to_alpha_color::<Srgb>())
-    }
-}
-
-impl<CS: ColorSpace> From<OpaqueColor<CS>> for BrushRef<'_> {
-    fn from(color: OpaqueColor<CS>) -> Self {
-        Self::Solid(color.with_alpha(1.).convert())
-    }
-}
-
-impl<'a, CS: ColorSpace> From<&'a AlphaColor<CS>> for BrushRef<'_> {
-    fn from(color: &'a AlphaColor<CS>) -> Self {
-        Self::Solid((*color).convert())
-    }
-}
-
-impl<'a> From<&'a DynamicColor> for BrushRef<'_> {
-    fn from(color: &'a DynamicColor) -> Self {
-        Self::Solid((*color).to_alpha_color::<Srgb>())
-    }
-}
-
-impl<'a, CS: ColorSpace> From<&'a OpaqueColor<CS>> for BrushRef<'_> {
-    fn from(color: &'a OpaqueColor<CS>) -> Self {
-        Self::Solid((*color).with_alpha(1.).convert())
-    }
-}
-
 impl<'a> From<&'a Gradient> for BrushRef<'a> {
     fn from(gradient: &'a Gradient) -> Self {
         Self::Gradient(gradient)
     }
 }
 
-impl<'a> From<ImageBrushRef<'a>> for BrushRef<'a> {
-    fn from(image: ImageBrushRef<'a>) -> Self {
-        Self::Image(image)
-    }
-}
-
 impl<'a> From<&'a ImageBrush> for BrushRef<'a> {
     fn from(image: &'a ImageBrush) -> Self {
         Self::Image(image.as_ref())