GNOME.org
 

[librsvg: 11/17] FilterEffect::resolve - return a ResolvedPrimitive instead of a tuple


commit 909ecbf9974b5219ec6e6c057572a0acf1d2f23a
Author: Federico Mena Quintero <federico gnome org>
Date:   Fri Apr 16 19:40:58 2021 -0500

    FilterEffect::resolve - return a ResolvedPrimitive instead of a tuple

 src/filters/blend.rs              |  9 ++++++---
 src/filters/color_matrix.rs       |  9 ++++++---
 src/filters/component_transfer.rs | 12 ++++++------
 src/filters/composite.rs          |  9 ++++++---
 src/filters/convolve_matrix.rs    |  9 ++++++---
 src/filters/displacement_map.rs   |  9 ++++++---
 src/filters/flood.rs              | 12 ++++++------
 src/filters/gaussian_blur.rs      |  9 ++++++---
 src/filters/image.rs              | 12 ++++++------
 src/filters/lighting.rs           | 18 +++++++++---------
 src/filters/merge.rs              | 14 +++++++-------
 src/filters/mod.rs                | 23 ++++++++++++++---------
 src/filters/morphology.rs         | 12 ++++++------
 src/filters/offset.rs             | 12 ++++++------
 src/filters/tile.rs               | 12 ++++++------
 src/filters/turbulence.rs         |  9 ++++++---
 16 files changed, 108 insertions(+), 82 deletions(-)
---
diff --git a/src/filters/blend.rs b/src/filters/blend.rs
index 637f6539..b0fc5afb 100644
--- a/src/filters/blend.rs
+++ b/src/filters/blend.rs
@@ -13,7 +13,7 @@ use crate::xml::Attributes;
 
 use super::bounds::BoundsBuilder;
 use super::context::{FilterContext, FilterOutput};
-use super::{FilterEffect, FilterError, Input, Primitive, PrimitiveParams};
+use super::{FilterEffect, FilterError, Input, Primitive, PrimitiveParams, ResolvedPrimitive};
 
 /// Enumeration of the possible blending modes.
 #[derive(Debug, Clone, Copy, Eq, PartialEq, Hash)]
@@ -108,14 +108,17 @@ impl Blend {
 }
 
 impl FilterEffect for FeBlend {
-    fn resolve(&self, node: &Node) -> Result<(Primitive, PrimitiveParams), FilterError> {
+    fn resolve(&self, node: &Node) -> Result<ResolvedPrimitive, FilterError> {
         let cascaded = CascadedValues::new_from_node(node);
         let values = cascaded.get();
 
         let mut params = self.params.clone();
         params.color_interpolation_filters = values.color_interpolation_filters();
 
-        Ok((self.base.clone(), PrimitiveParams::Blend(params)))
+        Ok(ResolvedPrimitive {
+            primitive: self.base.clone(),
+            params: PrimitiveParams::Blend(params),
+        })
     }
 }
 
diff --git a/src/filters/color_matrix.rs b/src/filters/color_matrix.rs
index 76bd198f..d466f0a4 100644
--- a/src/filters/color_matrix.rs
+++ b/src/filters/color_matrix.rs
@@ -18,7 +18,7 @@ use crate::xml::Attributes;
 
 use super::bounds::BoundsBuilder;
 use super::context::{FilterContext, FilterOutput};
-use super::{FilterEffect, FilterError, Input, Primitive, PrimitiveParams};
+use super::{FilterEffect, FilterError, Input, Primitive, PrimitiveParams, ResolvedPrimitive};
 
 /// Color matrix operation types.
 #[derive(Debug, Clone, Copy, Eq, PartialEq)]
@@ -217,14 +217,17 @@ impl ColorMatrix {
 }
 
 impl FilterEffect for FeColorMatrix {
-    fn resolve(&self, node: &Node) -> Result<(Primitive, PrimitiveParams), FilterError> {
+    fn resolve(&self, node: &Node) -> Result<ResolvedPrimitive, FilterError> {
         let cascaded = CascadedValues::new_from_node(node);
         let values = cascaded.get();
 
         let mut params = self.params.clone();
         params.color_interpolation_filters = values.color_interpolation_filters();
 
-        Ok((self.base.clone(), PrimitiveParams::ColorMatrix(params)))
+        Ok(ResolvedPrimitive {
+            primitive: self.base.clone(),
+            params: PrimitiveParams::ColorMatrix(params),
+        })
     }
 }
 
diff --git a/src/filters/component_transfer.rs b/src/filters/component_transfer.rs
index c6031d60..4b8c152e 100644
--- a/src/filters/component_transfer.rs
+++ b/src/filters/component_transfer.rs
@@ -19,7 +19,7 @@ use crate::xml::Attributes;
 
 use super::bounds::BoundsBuilder;
 use super::context::{FilterContext, FilterOutput};
-use super::{FilterEffect, FilterError, Input, Primitive, PrimitiveParams};
+use super::{FilterEffect, FilterError, Input, Primitive, PrimitiveParams, ResolvedPrimitive};
 
 /// The `feComponentTransfer` filter primitive.
 #[derive(Default)]
@@ -368,7 +368,7 @@ impl ComponentTransfer {
 }
 
 impl FilterEffect for FeComponentTransfer {
-    fn resolve(&self, node: &Node) -> Result<(Primitive, PrimitiveParams), FilterError> {
+    fn resolve(&self, node: &Node) -> Result<ResolvedPrimitive, FilterError> {
         let cascaded = CascadedValues::new_from_node(node);
         let values = cascaded.get();
 
@@ -376,10 +376,10 @@ impl FilterEffect for FeComponentTransfer {
         params.functions = get_functions(node)?;
         params.color_interpolation_filters = values.color_interpolation_filters();
 
-        Ok((
-            self.base.clone(),
-            PrimitiveParams::ComponentTransfer(params),
-        ))
+        Ok(ResolvedPrimitive {
+            primitive: self.base.clone(),
+            params: PrimitiveParams::ComponentTransfer(params),
+        })
     }
 }
 
diff --git a/src/filters/composite.rs b/src/filters/composite.rs
index a0707242..4a08ddca 100644
--- a/src/filters/composite.rs
+++ b/src/filters/composite.rs
@@ -13,7 +13,7 @@ use crate::xml::Attributes;
 
 use super::bounds::BoundsBuilder;
 use super::context::{FilterContext, FilterOutput};
-use super::{FilterEffect, FilterError, Input, Primitive, PrimitiveParams};
+use super::{FilterEffect, FilterError, Input, Primitive, PrimitiveParams, ResolvedPrimitive};
 
 /// Enumeration of the possible compositing operations.
 #[derive(Debug, Clone, Copy, Eq, PartialEq, Hash)]
@@ -118,14 +118,17 @@ impl Composite {
 }
 
 impl FilterEffect for FeComposite {
-    fn resolve(&self, node: &Node) -> Result<(Primitive, PrimitiveParams), FilterError> {
+    fn resolve(&self, node: &Node) -> Result<ResolvedPrimitive, FilterError> {
         let cascaded = CascadedValues::new_from_node(node);
         let values = cascaded.get();
 
         let mut params = self.params.clone();
         params.color_interpolation_filters = values.color_interpolation_filters();
 
-        Ok((self.base.clone(), PrimitiveParams::Composite(params)))
+        Ok(ResolvedPrimitive {
+            primitive: self.base.clone(),
+            params: PrimitiveParams::Composite(params),
+        })
     }
 }
 
diff --git a/src/filters/convolve_matrix.rs b/src/filters/convolve_matrix.rs
index 0bfad70a..1e4318a1 100644
--- a/src/filters/convolve_matrix.rs
+++ b/src/filters/convolve_matrix.rs
@@ -22,7 +22,7 @@ use crate::xml::Attributes;
 
 use super::bounds::BoundsBuilder;
 use super::context::{FilterContext, FilterOutput};
-use super::{FilterEffect, FilterError, Input, Primitive, PrimitiveParams};
+use super::{FilterEffect, FilterError, Input, Primitive, PrimitiveParams, ResolvedPrimitive};
 
 /// The `feConvolveMatrix` filter primitive.
 #[derive(Default)]
@@ -300,14 +300,17 @@ impl ConvolveMatrix {
 }
 
 impl FilterEffect for FeConvolveMatrix {
-    fn resolve(&self, node: &Node) -> Result<(Primitive, PrimitiveParams), FilterError> {
+    fn resolve(&self, node: &Node) -> Result<ResolvedPrimitive, FilterError> {
         let cascaded = CascadedValues::new_from_node(node);
         let values = cascaded.get();
 
         let mut params = self.params.clone();
         params.color_interpolation_filters = values.color_interpolation_filters();
 
-        Ok((self.base.clone(), PrimitiveParams::ConvolveMatrix(params)))
+        Ok(ResolvedPrimitive {
+            primitive: self.base.clone(),
+            params: PrimitiveParams::ConvolveMatrix(params),
+        })
     }
 }
 
diff --git a/src/filters/displacement_map.rs b/src/filters/displacement_map.rs
index 2d84967b..07bc125d 100644
--- a/src/filters/displacement_map.rs
+++ b/src/filters/displacement_map.rs
@@ -14,7 +14,7 @@ use crate::xml::Attributes;
 
 use super::bounds::BoundsBuilder;
 use super::context::{FilterContext, FilterOutput};
-use super::{FilterEffect, FilterError, Input, Primitive, PrimitiveParams};
+use super::{FilterEffect, FilterError, Input, Primitive, PrimitiveParams, ResolvedPrimitive};
 
 /// Enumeration of the color channels the displacement map can source.
 #[derive(Clone, Copy)]
@@ -152,14 +152,17 @@ impl DisplacementMap {
 }
 
 impl FilterEffect for FeDisplacementMap {
-    fn resolve(&self, node: &Node) -> Result<(Primitive, PrimitiveParams), FilterError> {
+    fn resolve(&self, node: &Node) -> Result<ResolvedPrimitive, FilterError> {
         let cascaded = CascadedValues::new_from_node(node);
         let values = cascaded.get();
 
         let mut params = self.params.clone();
         params.color_interpolation_filters = values.color_interpolation_filters();
 
-        Ok((self.base.clone(), PrimitiveParams::DisplacementMap(params)))
+        Ok(ResolvedPrimitive {
+            primitive: self.base.clone(),
+            params: PrimitiveParams::DisplacementMap(params),
+        })
     }
 }
 
diff --git a/src/filters/flood.rs b/src/filters/flood.rs
index dee1b01a..29a3ec7e 100644
--- a/src/filters/flood.rs
+++ b/src/filters/flood.rs
@@ -8,7 +8,7 @@ use crate::xml::Attributes;
 
 use super::bounds::BoundsBuilder;
 use super::context::{FilterContext, FilterOutput};
-use super::{FilterEffect, FilterError, Primitive, PrimitiveParams};
+use super::{FilterEffect, FilterError, Primitive, PrimitiveParams, ResolvedPrimitive};
 
 /// The `feFlood` filter primitive.
 #[derive(Default)]
@@ -44,19 +44,19 @@ impl Flood {
 }
 
 impl FilterEffect for FeFlood {
-    fn resolve(&self, node: &Node) -> Result<(Primitive, PrimitiveParams), FilterError> {
+    fn resolve(&self, node: &Node) -> Result<ResolvedPrimitive, FilterError> {
         let cascaded = CascadedValues::new_from_node(node);
         let values = cascaded.get();
 
-        Ok((
-            self.base.clone(),
-            PrimitiveParams::Flood(Flood {
+        Ok(ResolvedPrimitive {
+            primitive: self.base.clone(),
+            params: PrimitiveParams::Flood(Flood {
                 color: resolve_color(
                     &values.flood_color().0,
                     values.flood_opacity().0,
                     values.color().0,
                 ),
             }),
-        ))
+        })
     }
 }
diff --git a/src/filters/gaussian_blur.rs b/src/filters/gaussian_blur.rs
index 6a44235b..26cd3524 100644
--- a/src/filters/gaussian_blur.rs
+++ b/src/filters/gaussian_blur.rs
@@ -19,7 +19,7 @@ use crate::xml::Attributes;
 
 use super::bounds::BoundsBuilder;
 use super::context::{FilterContext, FilterOutput};
-use super::{FilterEffect, FilterError, Input, Primitive, PrimitiveParams};
+use super::{FilterEffect, FilterError, Input, Primitive, PrimitiveParams, ResolvedPrimitive};
 
 /// The maximum gaussian blur kernel size.
 ///
@@ -244,13 +244,16 @@ impl GaussianBlur {
 }
 
 impl FilterEffect for FeGaussianBlur {
-    fn resolve(&self, node: &Node) -> Result<(Primitive, PrimitiveParams), FilterError> {
+    fn resolve(&self, node: &Node) -> Result<ResolvedPrimitive, FilterError> {
         let cascaded = CascadedValues::new_from_node(node);
         let values = cascaded.get();
 
         let mut params = self.params.clone();
         params.color_interpolation_filters = values.color_interpolation_filters();
 
-        Ok((self.base.clone(), PrimitiveParams::GaussianBlur(params)))
+        Ok(ResolvedPrimitive {
+            primitive: self.base.clone(),
+            params: PrimitiveParams::GaussianBlur(params),
+        })
     }
 }
diff --git a/src/filters/image.rs b/src/filters/image.rs
index 3e2614bb..b19ab2d6 100644
--- a/src/filters/image.rs
+++ b/src/filters/image.rs
@@ -15,7 +15,7 @@ use crate::xml::Attributes;
 
 use super::bounds::{Bounds, BoundsBuilder};
 use super::context::{FilterContext, FilterOutput};
-use super::{FilterEffect, FilterError, Primitive, PrimitiveParams};
+use super::{FilterEffect, FilterError, Primitive, PrimitiveParams, ResolvedPrimitive};
 
 /// The `feImage` filter primitive.
 #[derive(Default)]
@@ -153,16 +153,16 @@ impl Image {
 }
 
 impl FilterEffect for FeImage {
-    fn resolve(&self, node: &Node) -> Result<(Primitive, PrimitiveParams), FilterError> {
+    fn resolve(&self, node: &Node) -> Result<ResolvedPrimitive, FilterError> {
         let cascaded = CascadedValues::new_from_node(node);
         let feimage_values = cascaded.get().clone();
 
-        Ok((
-            self.base.clone(),
-            PrimitiveParams::Image(Image {
+        Ok(ResolvedPrimitive {
+            primitive: self.base.clone(),
+            params: PrimitiveParams::Image(Image {
                 params: self.params.clone(),
                 feimage_values,
             }),
-        ))
+        })
     }
 }
diff --git a/src/filters/lighting.rs b/src/filters/lighting.rs
index fb5d6690..0588b3de 100644
--- a/src/filters/lighting.rs
+++ b/src/filters/lighting.rs
@@ -13,7 +13,7 @@ use crate::element::{Draw, Element, ElementResult, SetAttributes};
 use crate::filters::{
     bounds::BoundsBuilder,
     context::{FilterContext, FilterOutput},
-    FilterEffect, FilterError, Input, Primitive, PrimitiveParams,
+    FilterEffect, FilterError, Input, Primitive, PrimitiveParams, ResolvedPrimitive,
 };
 use crate::node::{CascadedValues, Node, NodeBorrow};
 use crate::paint_server::resolve_color;
@@ -649,7 +649,7 @@ macro_rules! impl_lighting_filter {
         }
 
         impl FilterEffect for $lighting_type {
-            fn resolve(&self, node: &Node) -> Result<(Primitive, PrimitiveParams), FilterError> {
+            fn resolve(&self, node: &Node) -> Result<ResolvedPrimitive, FilterError> {
                 let mut sources = node.children().rev().filter(|c| {
                     c.is_element()
                         && matches!(
@@ -688,9 +688,9 @@ macro_rules! impl_lighting_filter {
                 let cascaded = CascadedValues::new_from_node(node);
                 let values = cascaded.get();
 
-                Ok((
-                    self.base.clone(),
-                    PrimitiveParams::$params_name($params_name {
+                Ok(ResolvedPrimitive {
+                    primitive: self.base.clone(),
+                    params: PrimitiveParams::$params_name($params_name {
                         params: self.params.clone(),
                         light: Light {
                             source,
@@ -702,7 +702,7 @@ macro_rules! impl_lighting_filter {
                             color_interpolation_filters: values.color_interpolation_filters(),
                         },
                     }),
-                ))
+                })
             }
         }
     };
@@ -992,7 +992,7 @@ mod tests {
 
         let node = document.lookup_internal_node("diffuse_distant").unwrap();
         let lighting = borrow_element_as!(node, FeDiffuseLighting);
-        let (_, params) = lighting.resolve(&node).unwrap();
+        let ResolvedPrimitive { params, .. } = lighting.resolve(&node).unwrap();
         let diffuse_lighting = match params {
             PrimitiveParams::DiffuseLighting(l) => l,
             _ => unreachable!(),
@@ -1007,7 +1007,7 @@ mod tests {
 
         let node = document.lookup_internal_node("specular_point").unwrap();
         let lighting = borrow_element_as!(node, FeSpecularLighting);
-        let (_, params) = lighting.resolve(&node).unwrap();
+        let ResolvedPrimitive { params, .. } = lighting.resolve(&node).unwrap();
         let specular_lighting = match params {
             PrimitiveParams::SpecularLighting(l) => l,
             _ => unreachable!(),
@@ -1023,7 +1023,7 @@ mod tests {
 
         let node = document.lookup_internal_node("diffuse_spot").unwrap();
         let lighting = borrow_element_as!(node, FeDiffuseLighting);
-        let (_, params) = lighting.resolve(&node).unwrap();
+        let ResolvedPrimitive { params, .. } = lighting.resolve(&node).unwrap();
         let diffuse_lighting = match params {
             PrimitiveParams::DiffuseLighting(l) => l,
             _ => unreachable!(),
diff --git a/src/filters/merge.rs b/src/filters/merge.rs
index b8b49857..e01348a4 100644
--- a/src/filters/merge.rs
+++ b/src/filters/merge.rs
@@ -12,7 +12,7 @@ use crate::xml::Attributes;
 
 use super::bounds::BoundsBuilder;
 use super::context::{FilterContext, FilterOutput};
-use super::{FilterEffect, FilterError, Input, Primitive, PrimitiveParams};
+use super::{FilterEffect, FilterError, Input, Primitive, PrimitiveParams, ResolvedPrimitive};
 
 /// The `feMerge` filter primitive.
 pub struct FeMerge {
@@ -139,13 +139,13 @@ impl Merge {
 }
 
 impl FilterEffect for FeMerge {
-    fn resolve(&self, node: &Node) -> Result<(Primitive, PrimitiveParams), FilterError> {
-        Ok((
-            self.base.clone(),
-            PrimitiveParams::Merge(Merge {
+    fn resolve(&self, node: &Node) -> Result<ResolvedPrimitive, FilterError> {
+        Ok(ResolvedPrimitive {
+            primitive: self.base.clone(),
+            params: PrimitiveParams::Merge(Merge {
                 merge_nodes: resolve_merge_nodes(node)?,
             }),
-        ))
+        })
     }
 }
 
@@ -196,7 +196,7 @@ mod tests {
 
         let node = document.lookup_internal_node("merge").unwrap();
         let merge = borrow_element_as!(node, FeMerge);
-        let (_, params) = merge.resolve(&node).unwrap();
+        let ResolvedPrimitive { params, .. } = merge.resolve(&node).unwrap();
         let params = match params {
             PrimitiveParams::Merge(m) => m,
             _ => unreachable!(),
diff --git a/src/filters/mod.rs b/src/filters/mod.rs
index 19ef1185..d821ecd9 100644
--- a/src/filters/mod.rs
+++ b/src/filters/mod.rs
@@ -31,7 +31,7 @@ use self::error::FilterError;
 
 /// A filter primitive interface.
 pub trait FilterEffect: SetAttributes + Draw {
-    fn resolve(&self, node: &Node) -> Result<(Primitive, PrimitiveParams), FilterError>;
+    fn resolve(&self, node: &Node) -> Result<ResolvedPrimitive, FilterError>;
 }
 
 // Filter Effects do not need to draw themselves
@@ -114,6 +114,11 @@ pub struct Primitive {
     result: Option<CustomIdent>,
 }
 
+pub struct ResolvedPrimitive {
+    pub primitive: Primitive,
+    pub params: PrimitiveParams,
+}
+
 /// Common properties for filter primitives, with all lengths in user space coordinates.
 pub struct UserSpacePrimitive {
     x: Option<f64>,
@@ -159,7 +164,7 @@ impl Parse for Input {
     }
 }
 
-impl Primitive {
+impl ResolvedPrimitive {
     fn to_user_space(
         &self,
         primitive_units: CoordUnits,
@@ -168,17 +173,17 @@ impl Primitive {
     ) -> UserSpacePrimitive {
         let params = draw_ctx.push_coord_units(primitive_units);
 
-        let x = self.x.map(|l| l.normalize(values, &params));
-        let y = self.y.map(|l| l.normalize(values, &params));
-        let width = self.width.map(|l| l.normalize(values, &params));
-        let height = self.height.map(|l| l.normalize(values, &params));
+        let x = self.primitive.x.map(|l| l.normalize(values, &params));
+        let y = self.primitive.y.map(|l| l.normalize(values, &params));
+        let width = self.primitive.width.map(|l| l.normalize(values, &params));
+        let height = self.primitive.height.map(|l| l.normalize(values, &params));
 
         UserSpacePrimitive {
             x,
             y,
             width,
             height,
-            result: self.result.clone(),
+            result: self.primitive.result.clone(),
         }
     }
 }
@@ -294,14 +299,14 @@ pub fn render(
                     );
                     e
                 })
-                .and_then(|(primitive, params)| {
+                .and_then(|primitive| {
                     let user_space_primitive = primitive.to_user_space(
                         user_space_filter.primitive_units,
                         primitive_values,
                         draw_ctx,
                     );
 
-                    Ok((user_space_primitive, params))
+                    Ok((user_space_primitive, primitive.params))
                 })
         })
         .collect::<Result<Vec<(UserSpacePrimitive, PrimitiveParams)>, FilterError>>();
diff --git a/src/filters/morphology.rs b/src/filters/morphology.rs
index ec6e753f..d6f8ccb6 100644
--- a/src/filters/morphology.rs
+++ b/src/filters/morphology.rs
@@ -20,7 +20,7 @@ use crate::xml::Attributes;
 
 use super::bounds::BoundsBuilder;
 use super::context::{FilterContext, FilterOutput};
-use super::{FilterEffect, FilterError, Input, Primitive, PrimitiveParams};
+use super::{FilterEffect, FilterError, Input, Primitive, PrimitiveParams, ResolvedPrimitive};
 
 /// Enumeration of the possible morphology operations.
 #[derive(Clone)]
@@ -158,11 +158,11 @@ impl Morphology {
 }
 
 impl FilterEffect for FeMorphology {
-    fn resolve(&self, _node: &Node) -> Result<(Primitive, PrimitiveParams), FilterError> {
-        Ok((
-            self.base.clone(),
-            PrimitiveParams::Morphology(self.params.clone()),
-        ))
+    fn resolve(&self, _node: &Node) -> Result<ResolvedPrimitive, FilterError> {
+        Ok(ResolvedPrimitive {
+            primitive: self.base.clone(),
+            params: PrimitiveParams::Morphology(self.params.clone()),
+        })
     }
 }
 
diff --git a/src/filters/offset.rs b/src/filters/offset.rs
index e97369d6..662fea92 100644
--- a/src/filters/offset.rs
+++ b/src/filters/offset.rs
@@ -11,7 +11,7 @@ use crate::xml::Attributes;
 
 use super::bounds::BoundsBuilder;
 use super::context::{FilterContext, FilterOutput};
-use super::{FilterEffect, FilterError, Input, Primitive, PrimitiveParams};
+use super::{FilterEffect, FilterError, Input, Primitive, PrimitiveParams, ResolvedPrimitive};
 
 /// The `feOffset` filter primitive.
 #[derive(Default)]
@@ -80,10 +80,10 @@ impl Offset {
 }
 
 impl FilterEffect for FeOffset {
-    fn resolve(&self, _node: &Node) -> Result<(Primitive, PrimitiveParams), FilterError> {
-        Ok((
-            self.base.clone(),
-            PrimitiveParams::Offset(self.params.clone()),
-        ))
+    fn resolve(&self, _node: &Node) -> Result<ResolvedPrimitive, FilterError> {
+        Ok(ResolvedPrimitive {
+            primitive: self.base.clone(),
+            params: PrimitiveParams::Offset(self.params.clone()),
+        })
     }
 }
diff --git a/src/filters/tile.rs b/src/filters/tile.rs
index 6f431fbc..108f7816 100644
--- a/src/filters/tile.rs
+++ b/src/filters/tile.rs
@@ -8,7 +8,7 @@ use crate::xml::Attributes;
 
 use super::bounds::BoundsBuilder;
 use super::context::{FilterContext, FilterInput, FilterOutput};
-use super::{FilterEffect, FilterError, Input, Primitive, PrimitiveParams};
+use super::{FilterEffect, FilterError, Input, Primitive, PrimitiveParams, ResolvedPrimitive};
 
 /// The `feTile` filter primitive.
 #[derive(Default)]
@@ -77,10 +77,10 @@ impl Tile {
 }
 
 impl FilterEffect for FeTile {
-    fn resolve(&self, _node: &Node) -> Result<(Primitive, PrimitiveParams), FilterError> {
-        Ok((
-            self.base.clone(),
-            PrimitiveParams::Tile(self.params.clone()),
-        ))
+    fn resolve(&self, _node: &Node) -> Result<ResolvedPrimitive, FilterError> {
+        Ok(ResolvedPrimitive {
+            primitive: self.base.clone(),
+            params: PrimitiveParams::Tile(self.params.clone()),
+        })
     }
 }
diff --git a/src/filters/turbulence.rs b/src/filters/turbulence.rs
index 02694185..8cb3b3ad 100644
--- a/src/filters/turbulence.rs
+++ b/src/filters/turbulence.rs
@@ -18,7 +18,7 @@ use crate::xml::Attributes;
 
 use super::bounds::BoundsBuilder;
 use super::context::{FilterContext, FilterOutput};
-use super::{FilterEffect, FilterError, Primitive, PrimitiveParams};
+use super::{FilterEffect, FilterError, Primitive, PrimitiveParams, ResolvedPrimitive};
 
 /// Enumeration of the tile stitching modes.
 #[derive(Debug, Clone, Copy, Eq, PartialEq, Hash)]
@@ -415,14 +415,17 @@ impl Turbulence {
 }
 
 impl FilterEffect for FeTurbulence {
-    fn resolve(&self, node: &Node) -> Result<(Primitive, PrimitiveParams), FilterError> {
+    fn resolve(&self, node: &Node) -> Result<ResolvedPrimitive, FilterError> {
         let cascaded = CascadedValues::new_from_node(node);
         let values = cascaded.get();
 
         let mut params = self.params.clone();
         params.color_interpolation_filters = values.color_interpolation_filters();
 
-        Ok((self.base.clone(), PrimitiveParams::Turbulence(params)))
+        Ok(ResolvedPrimitive {
+            primitive: self.base.clone(),
+            params: PrimitiveParams::Turbulence(params),
+        })
     }
 }
[Date Prev][Date Next]   [Thread Prev][Thread Next]   [Thread Index] [Date Index] [Author Index]