pub fn new(

        cr: &'a cairo::Context,

        transform: ValidTransform,

        cairo_path: &'a CairoPath,

    ) -> Self {

        PathHelper {

            cr,

            transform,

            cairo_path,

            has_path: None,

        }

    }

    pub fn set(&mut self) -> Result<(), InternalRenderingError> {

        match self.has_path {

                self.has_path = Some(true);

                self.cr.set_matrix(self.transform.into());

                self.cairo_path.to_cairo_context(self.cr)

            Some(true) => Ok(()),

    }

    pub fn unset(&mut self) {

        match self.has_path {

            Some(true) | None => {

                self.has_path = Some(false);

                self.cr.new_path();

            }

            Some(false) => {}

    }

    pub fn new(dpi: Dpi, view_box_width: f64, view_box_height: f64) -> Viewport {

        Viewport {

            dpi,

            vbox: ViewBox::from(Rect::from_size(view_box_width, view_box_height)),

            transform: Default::default(),

        }

    }

    pub fn with_units(&self, units: CoordUnits) -> Viewport {

        match units {

            CoordUnits::ObjectBoundingBox => Viewport {

                dpi: self.dpi,

                vbox: ViewBox::from(Rect::from_size(1.0, 1.0)),

                transform: self.transform,

            },

            CoordUnits::UserSpaceOnUse => Viewport {

                dpi: self.dpi,

                vbox: self.vbox,

                transform: self.transform,

            },

    }

    pub fn with_view_box(&self, width: f64, height: f64) -> Viewport {

        Viewport {

            dpi: self.dpi,

            vbox: ViewBox::from(Rect::from_size(width, height)),

            transform: self.transform,

        }

    }

    pub fn with_explicit_transform(&self, transform: ValidTransform) -> Viewport {

        Viewport {

            dpi: self.dpi,

            vbox: self.vbox,

            transform,

        }

    }

    pub fn with_composed_transform(

        &self,

        transform: ValidTransform,

    ) -> Result<Viewport, InvalidTransform> {

        let composed_transform =

            ValidTransform::try_from((*self.transform).pre_transform(&transform))?;

        Ok(Viewport {

            dpi: self.dpi,

            vbox: self.vbox,

            transform: composed_transform,

        })

    }

    pub fn empty_bbox(&self) -> BoundingBox {

        BoundingBox::new().with_transform(*self.transform)

    }

pub fn draw_tree(

    session: Session,

    mode: DrawingMode,

    cr: &cairo::Context,

    viewport_rect: Rect,

    config: RenderingConfiguration,

    acquired_nodes: &mut AcquiredNodes<'_>,

) -> Result<BoundingBox, InternalRenderingError> {

    let (drawsub_stack, node) = match mode {

        DrawingMode::LimitToStack { node, root } => (node.ancestors().collect(), root),

        DrawingMode::OnlyNode(node) => (Vec::new(), node),

    let cascaded = CascadedValues::new_from_node(&node);

    // Preserve the user's transform and use it for the outermost bounding box.  All bounds/extents

    // will be converted to this transform in the end.

    let user_transform = Transform::from(cr.matrix());

    let mut user_bbox = BoundingBox::new().with_transform(user_transform);

    // https://www.w3.org/TR/SVG2/coords.html#InitialCoordinateSystem

    //

    // "For the outermost svg element, the SVG user agent must

    // determine an initial viewport coordinate system and an

    // initial user coordinate system such that the two

    // coordinates systems are identical. The origin of both

    // coordinate systems must be at the origin of the SVG

    // viewport."

    //

    // "... the initial viewport coordinate system (and therefore

    // the initial user coordinate system) must have its origin at

    // the top/left of the viewport"

    // Translate so (0, 0) is at the viewport's upper-left corner.

    let transform = user_transform.pre_translate(viewport_rect.x0, viewport_rect.y0);

    let valid_transform = ValidTransform::try_from(transform)?;

    cr.set_matrix(valid_transform.into());

    // Per the spec, so the viewport has (0, 0) as upper-left.

    let viewport_rect = viewport_rect.translate((-viewport_rect.x0, -viewport_rect.y0));

    let initial_viewport = Viewport {

        dpi: config.dpi,

        vbox: ViewBox::from(viewport_rect),

        transform: valid_transform,

    };

    let mut draw_ctx = DrawingCtx::new(session, cr, &initial_viewport, config, drawsub_stack);

    let content_bbox = draw_ctx.draw_node_from_stack(

        &node,

        acquired_nodes,

        &cascaded,

        &initial_viewport,

        false,

    )?;

    user_bbox.insert(&content_bbox);

    if draw_ctx.is_rendering_cancelled() {

        Ok(user_bbox)

}

pub fn with_saved_cr<O, F>(cr: &cairo::Context, f: F) -> Result<O, InternalRenderingError>

where

    F: FnOnce() -> Result<O, InternalRenderingError>,

{

    cr.save()?;

    match f() {

        Ok(o) => {

            cr.restore()?;

            Ok(o)

        Err(e) => Err(e),

}

    fn drop(&mut self) {

        self.cr_stack.borrow_mut().pop();

    }

    pub fn new(

        session: Session,

        cr: &cairo::Context,

        initial_viewport: &Viewport,

        config: RenderingConfiguration,

        drawsub_stack: Vec<Node>,

    ) -> DrawingCtx {

        DrawingCtx {

            session,

            initial_viewport: *initial_viewport,

            cr_stack: Rc::new(RefCell::new(Vec::new())),

            cr: cr.clone(),

            drawsub_stack,

            config,

            recursion_depth: 0,

        }

    }

    fn nested(&self, cr: cairo::Context) -> Box<DrawingCtx> {

        let cr_stack = self.cr_stack.clone();

        cr_stack.borrow_mut().push(self.cr.clone());

        Box::new(DrawingCtx {

            session: self.session.clone(),

            initial_viewport: self.initial_viewport,

            cr_stack,

            cr,

            drawsub_stack: self.drawsub_stack.clone(),

            config: self.config.clone(),

            recursion_depth: self.recursion_depth,

        })

    }

    pub fn session(&self) -> &Session {

        &self.session

    }

    pub fn rendering_options(&self, svg_nesting: SvgNesting) -> RenderingOptions {

        RenderingOptions {

            dpi: self.config.dpi,

            cancellable: self.config.cancellable.clone(),

            user_language: self.config.user_language.clone(),

            svg_nesting,

            testing: self.config.testing,

        }

    }

    pub fn user_language(&self) -> &UserLanguage {

        &self.config.user_language

    }

    pub fn toplevel_viewport(&self) -> Rect {

        *self.initial_viewport.vbox

    }

    fn get_transform_for_stacking_ctx(

        &self,

        viewport: &Viewport,

        stacking_ctx: &StackingContext,

        clipping: bool,

    ) -> Result<ValidTransform, InternalRenderingError> {

        if stacking_ctx.should_isolate() && !clipping {

            let affines = CompositingAffines::new(

                *viewport.transform,

                *self.initial_viewport.transform,

                self.cr_stack.borrow().len(),

            );

            Ok(ValidTransform::try_from(affines.for_temporary_surface)?)

            Ok(viewport.transform)

    }

    pub fn svg_nesting(&self) -> SvgNesting {

        self.config.svg_nesting

    }

    pub fn is_measuring(&self) -> bool {

        self.config.measuring

    }

    fn size_for_temporary_surface(&self) -> (i32, i32) {

        let rect = self.toplevel_viewport();

        let (viewport_width, viewport_height) = (rect.width(), rect.height());

        let (width, height) = self

            .initial_viewport

            .transform

            .transform_distance(viewport_width, viewport_height);

        // We need a size in whole pixels, so use ceil() to ensure the whole viewport fits

        // into the temporary surface.

        (width.ceil().abs() as i32, height.ceil().abs() as i32)

    }

    pub fn create_surface_for_toplevel_viewport(

        &self,

    ) -> Result<cairo::ImageSurface, InternalRenderingError> {

        let (w, h) = self.size_for_temporary_surface();

        Ok(cairo::ImageSurface::create(cairo::Format::ARgb32, w, h)?)

    }

    fn create_similar_surface_for_toplevel_viewport(

        &self,

        surface: &cairo::Surface,

    ) -> Result<cairo::Surface, InternalRenderingError> {

        let (w, h) = self.size_for_temporary_surface();

        Ok(cairo::Surface::create_similar(

            surface,

            cairo::Content::ColorAlpha,

            w,

            h,

        )?)

    }

    fn push_new_viewport(

        &self,

        current_viewport: &Viewport,

        layout_viewport: &LayoutViewport,

    ) -> Option<Viewport> {

        let LayoutViewport {

            geometry,

            vbox,

            preserve_aspect_ratio,

            overflow,

        } = *layout_viewport;

        if !overflow.overflow_allowed() || (vbox.is_some() && preserve_aspect_ratio.is_slice()) {

            clip_to_rectangle(&self.cr, &current_viewport.transform, &geometry);

        }

        preserve_aspect_ratio

            .viewport_to_viewbox_transform(vbox, &geometry)

            .unwrap_or_else(|_e| {

                match vbox {

                    Some(v) => {

                        rsvg_log!(

                            self.session,

                None

            })

            .and_then(|t| {

                let transform =

                    ValidTransform::try_from(current_viewport.transform.pre_transform(&t)).ok()?;

                Some(Viewport {

                    dpi: self.config.dpi,

                    vbox: vbox.unwrap_or(current_viewport.vbox),

                    transform,

                })

            })

    }

    fn clip_to_node(

        &mut self,

        clip_node: &Option<Node>,

        acquired_nodes: &mut AcquiredNodes<'_>,

        viewport: &Viewport,

        bbox: &BoundingBox,

    ) -> Result<(), InternalRenderingError> {

        if clip_node.is_none() {

            return Ok(());

        }

        let node = clip_node.as_ref().unwrap();

        let units = borrow_element_as!(node, ClipPath).get_units();

        if let Ok(transform) = rect_to_transform(&bbox.rect, units) {

            let cascaded = CascadedValues::new_from_node(node);

            let values = cascaded.get();

            let node_transform = values.transform().post_transform(&transform);

            let transform_for_clip = ValidTransform::try_from(node_transform)?;

            let clip_viewport = viewport.with_composed_transform(transform_for_clip)?;

            for child in node.children().filter(|c| {

                c.is_element() && element_can_be_used_inside_clip_path(&c.borrow_element())

            }) {

                child.draw(

                    acquired_nodes,

                    &CascadedValues::clone_with_node(&cascaded, &child),

                    &clip_viewport,

                    self,

                    true,

                )?;

            self.cr.clip();

        }

        Ok(())

    }

    fn generate_cairo_mask(

        &mut self,

        mask_node: &Node,

        viewport: &Viewport,

        transform: Transform,

        bbox: &BoundingBox,

        acquired_nodes: &mut AcquiredNodes<'_>,

    ) -> Result<Option<cairo::ImageSurface>, InternalRenderingError> {

        if bbox.rect.is_none() {

            return Ok(None);

        }

        let _mask_acquired = match acquired_nodes.acquire_ref(mask_node) {

            Ok(n) => n,

        let mask_element = mask_node.borrow_element();

        let mask = borrow_element_as!(mask_node, Mask);

        let cascaded = CascadedValues::new_from_node(mask_node);

        let values = cascaded.get();

        let mask_units = mask.get_units();

        let mask_rect = {

            let params = NormalizeParams::new(values, &viewport.with_units(mask_units));

            mask.get_rect(&params)

        let transform_for_mask =

            ValidTransform::try_from(values.transform().post_transform(&transform))?;

        let bbtransform = if let Ok(t) = rect_to_transform(&bbox.rect, mask_units)

            .map_err(|_: ()| InvalidTransform)

            .and_then(ValidTransform::try_from)

            t

            return Ok(None);

        let mask_content_surface = self.create_surface_for_toplevel_viewport()?;

            let mask_cr = cairo::Context::new(&mask_content_surface)?;

            let clip_rect = (*bbtransform).transform_rect(&mask_rect);

            clip_to_rectangle(&mask_cr, &transform_for_mask, &clip_rect);

            let mask_viewport = if mask.get_content_units() == CoordUnits::ObjectBoundingBox {

                viewport

                    .with_units(mask.get_content_units())

                    .with_explicit_transform(transform_for_mask)

                    .with_composed_transform(bbtransform)?

                viewport

                    .with_units(mask.get_content_units())

                    .with_explicit_transform(transform_for_mask)

            let mut mask_draw_ctx = self.nested(mask_cr);

            let stacking_ctx = Box::new(StackingContext::new(

                self.session(),

                acquired_nodes,

                &mask_element,

                Transform::identity(),

                None,

                values,

            ));

            rsvg_log!(self.session, "(mask {}", mask_element);

            let res = mask_draw_ctx.with_discrete_layer(

                &stacking_ctx,

                acquired_nodes,

                &mask_viewport,

                None,

                false,

                &mut |an, dc, new_viewport| {

                    mask_node.draw_children(an, &cascaded, new_viewport, dc, false)

                },

            );

            rsvg_log!(self.session, ")");

            res?;

        let tmp = SharedImageSurface::wrap(mask_content_surface, SurfaceType::SRgb)?;

        let mask_result = match values.mask_type() {

            MaskType::Luminance => tmp.to_luminance_mask()?,

            MaskType::Alpha => tmp.extract_alpha(IRect::from_size(tmp.width(), tmp.height()))?,

        let mask = mask_result.into_image_surface()?;

        Ok(Some(mask))

    }

    fn is_rendering_cancelled(&self) -> bool {

        match &self.config.cancellable {

            None => false,

            Some(cancellable) => cancellable.is_cancelled(),

    }

    fn check_cancellation(&self) -> Result<(), InternalRenderingError> {

        if self.is_rendering_cancelled() {

            return Err(InternalRenderingError::Cancelled);

        }

        Ok(())

    }

    fn check_layer_nesting_depth(&self) -> Result<(), InternalRenderingError> {

        if self.recursion_depth > limits::MAX_LAYER_NESTING_DEPTH {

            return Err(InternalRenderingError::LimitExceeded(

                ImplementationLimit::MaximumLayerNestingDepthExceeded,

            ));

        }

        Ok(())

    }

    fn filter_current_surface(

        &mut self,

        acquired_nodes: &mut AcquiredNodes<'_>,

        filter: &Filter,

        viewport: &Viewport,

        element_name: &str,

        bbox: &BoundingBox,

    ) -> Result<cairo::Surface, InternalRenderingError> {

        let surface_to_filter = SharedImageSurface::copy_from_surface(

            &cairo::ImageSurface::try_from(self.cr.target()).unwrap(),

        )?;

        let stroke_paint_source = Rc::new(filter.stroke_paint_source.to_user_space(

            &bbox.rect,

            viewport,

            &filter.normalize_values,

        ));

        let fill_paint_source = Rc::new(filter.fill_paint_source.to_user_space(

            &bbox.rect,

            viewport,

            &filter.normalize_values,

        ));

        // Filter functions (like "blend()", not the <filter> element) require

        // being resolved in userSpaceonUse units, since that is the default

        // for primitive_units.  So, get the corresponding NormalizeParams

        // here and pass them down.

        let user_space_params = NormalizeParams::from_values(

            &filter.normalize_values,

            &viewport.with_units(CoordUnits::UserSpaceOnUse),

        );

        let filtered_surface = self

            .run_filters(

                viewport,

                surface_to_filter,

                filter,

                acquired_nodes,

                element_name,

                &user_space_params,

                stroke_paint_source,

                fill_paint_source,

                bbox,

            )?

            .into_image_surface()?;

        let generic_surface: &cairo::Surface = &filtered_surface; // deref to Surface

        Ok(generic_surface.clone())

    }

    fn draw_in_optional_new_viewport(

        &mut self,

        acquired_nodes: &mut AcquiredNodes<'_>,

        viewport: &Viewport,

        layout_viewport: &Option<LayoutViewport>,

        draw_fn: &mut dyn FnMut(

            &mut AcquiredNodes<'_>,

            &mut DrawingCtx,

            &Viewport,

        ) -> Result<BoundingBox, InternalRenderingError>,

    ) -> Result<BoundingBox, InternalRenderingError> {

        if let Some(layout_viewport) = layout_viewport.as_ref() {

            if let Some(new_viewport) = self.push_new_viewport(viewport, layout_viewport) {

                draw_fn(acquired_nodes, self, &new_viewport)

                Ok(viewport.empty_bbox())

            draw_fn(acquired_nodes, self, viewport)

    }

    fn draw_layer_internal(

        &mut self,

        stacking_ctx: &StackingContext,

        acquired_nodes: &mut AcquiredNodes<'_>,

        viewport: &Viewport,

        layout_viewport: Option<LayoutViewport>,

        clipping: bool,

        draw_fn: &mut dyn FnMut(

            &mut AcquiredNodes<'_>,

            &mut DrawingCtx,

            &Viewport,

        ) -> Result<BoundingBox, InternalRenderingError>,

    ) -> Result<BoundingBox, InternalRenderingError> {

        let stacking_ctx_transform = ValidTransform::try_from(stacking_ctx.transform)?;

        let viewport = viewport.with_composed_transform(stacking_ctx_transform)?;

        let res = if clipping {

            self.draw_in_optional_new_viewport(acquired_nodes, &viewport, &layout_viewport, draw_fn)

            with_saved_cr(&self.cr.clone(), || {

                if let Some(ref link_target) = stacking_ctx.link_target {

                    self.link_tag_begin(link_target);

                }

                let Opacity(UnitInterval(opacity)) = stacking_ctx.opacity;

                if let Some(rect) = stacking_ctx.clip_rect.as_ref() {

                    clip_to_rectangle(&self.cr, &viewport.transform, rect);

                }

                self.clip_to_node(

                    &stacking_ctx.clip_in_user_space,

                    acquired_nodes,

                    &viewport,

                    &viewport.empty_bbox(),

                )?;

                let should_isolate = stacking_ctx.should_isolate();

                let res = if should_isolate {

                    let affines = Box::new(CompositingAffines::new(

                        *viewport.transform,

                        *self.initial_viewport.transform,

                        self.cr_stack.borrow().len(),

                    ));

                    let cr = match stacking_ctx.filter {

                            &self

                                .create_similar_surface_for_toplevel_viewport(&self.cr.target())?,

                            cairo::Context::new(self.create_surface_for_toplevel_viewport()?)?

                    let transform_for_temporary_surface =

                        ValidTransform::try_from(affines.for_temporary_surface)?;

                    let (source_surface, mut res, bbox) = {

                        let mut temporary_draw_ctx = self.nested(cr.clone());

                        let viewport_for_temporary_surface = Viewport::with_explicit_transform(

                            &viewport,

                            transform_for_temporary_surface,

                        );

                        // Draw!

                        let res = temporary_draw_ctx.draw_in_optional_new_viewport(

                            acquired_nodes,

                            &viewport_for_temporary_surface,

                            &layout_viewport,

                            draw_fn,

                        );

                        let bbox = if let Ok(ref bbox) = res {

                            *bbox

                            BoundingBox::new().with_transform(*transform_for_temporary_surface)

                        if let Some(ref filter) = stacking_ctx.filter {

                            let filtered_surface = temporary_draw_ctx.filter_current_surface(

                                acquired_nodes,

                                filter,

                                &viewport_for_temporary_surface,

                                &stacking_ctx.element_name,

                                &bbox,

                            )?;

                            (filtered_surface, res, bbox)

                            (temporary_draw_ctx.cr.target(), res, bbox)

                    self.cr

                        .set_matrix(ValidTransform::try_from(affines.compositing)?.into());

                    self.cr.set_source_surface(&source_surface, 0.0, 0.0)?;

                    let transform_for_clip =

                        ValidTransform::try_from(affines.outside_temporary_surface)?;

                    let viewport_for_clip = viewport.with_explicit_transform(transform_for_clip);

                    self.cr.set_matrix(transform_for_clip.into());

                    self.clip_to_node(

                        &stacking_ctx.clip_in_object_space,

                        acquired_nodes,

                        &viewport_for_clip,

                        &bbox,

                    )?;

                    if let Some(ref mask_node) = stacking_ctx.mask {

                        res = res.and_then(|bbox| {

                            self.generate_cairo_mask(

                                mask_node,

                                &viewport,

                                affines.for_temporary_surface,

                                &bbox,

                                acquired_nodes,

                            )

                            .and_then(|mask_surf| {

                                if let Some(surf) = mask_surf {

                                    self.cr.push_group();

                                    self.cr.set_matrix(

                                        ValidTransform::try_from(affines.compositing)?.into(),

                                    );

                                    self.cr.mask_surface(&surf, 0.0, 0.0)?;

                                    Ok(self.cr.pop_group_to_source()?)

                                    Ok(())

                            })

                            .map(|_: ()| bbox)

                        });

                    }

                        self.cr

                            .set_matrix(ValidTransform::try_from(affines.compositing)?.into());

                        self.cr.set_operator(stacking_ctx.mix_blend_mode.into());

                        if opacity < 1.0 {

                            self.cr.paint_with_alpha(opacity)?;

                            self.cr.paint()?;

                    res

                    self.draw_in_optional_new_viewport(

                        acquired_nodes,

                        &viewport,

                        &layout_viewport,

                        draw_fn,

                    )

                if stacking_ctx.link_target.is_some() {

                    self.link_tag_end();

                }

                res

            })

        res

    }

    pub fn with_discrete_layer(

        &mut self,

        stacking_ctx: &StackingContext,

        acquired_nodes: &mut AcquiredNodes<'_>,

        viewport: &Viewport,

        layout_viewport: Option<LayoutViewport>,

        clipping: bool,

        draw_fn: &mut dyn FnMut(

            &mut AcquiredNodes<'_>,

            &mut DrawingCtx,

            &Viewport,

        ) -> Result<BoundingBox, InternalRenderingError>,

    ) -> Result<BoundingBox, InternalRenderingError> {

        self.check_cancellation()?;

        self.recursion_depth += 1;

        match self.check_layer_nesting_depth() {

                let res = self.draw_layer_internal(

                    stacking_ctx,

                    acquired_nodes,

                    viewport,

                    layout_viewport,

                    clipping,

                    draw_fn,

                );

                self.recursion_depth -= 1;

                res

            Err(e) => Err(e),

    }

    fn with_alpha(

        &mut self,

        opacity: UnitInterval,

        draw_fn: &mut dyn FnMut(&mut DrawingCtx) -> Result<BoundingBox, InternalRenderingError>,

    ) -> Result<BoundingBox, InternalRenderingError> {

        let res;

        let UnitInterval(o) = opacity;

        if o < 1.0 {

            self.cr.push_group();

            res = draw_fn(self);

            self.cr.pop_group_to_source()?;

            self.cr.paint_with_alpha(o)?;

        } else {

            res = draw_fn(self);

        }

        res

    }

    fn link_tag_begin(&mut self, link_target: &str) {

        let attributes = format!("uri='{}'", escape_link_target(link_target));

        let cr = self.cr.clone();

        cr.tag_begin(CAIRO_TAG_LINK, &attributes);

    }

    fn link_tag_end(&mut self) {

        self.cr.tag_end(CAIRO_TAG_LINK);

    }

    fn make_filter_plan(

        &mut self,

        acquired_nodes: &mut AcquiredNodes<'_>,

        specs: &[FilterSpec],

        source_image_width: i32,

        source_image_height: i32,

        stroke_paint_source: Rc<UserSpacePaintSource>,

        fill_paint_source: Rc<UserSpacePaintSource>,

        viewport: &Viewport,

    ) -> Result<Rc<FilterPlan>, InternalRenderingError> {

        let requirements = InputRequirements::new_from_filter_specs(specs);

        let background_image =

            if requirements.needs_background_image || requirements.needs_background_alpha {

                Some(self.get_snapshot(source_image_width, source_image_height)?)

                None

        let stroke_paint_image = if requirements.needs_stroke_paint_image {

            Some(self.get_paint_source_surface(

                source_image_width,

                source_image_height,

                acquired_nodes,

                &stroke_paint_source,

                viewport,

            )?)

            None

        let fill_paint_image = if requirements.needs_fill_paint_image {

            Some(self.get_paint_source_surface(

                source_image_width,

                source_image_height,

                acquired_nodes,

                &fill_paint_source,

                viewport,

            )?)

            None

        Ok(Rc::new(FilterPlan::new(

            self.session(),

            *viewport,

            requirements,

            background_image,

            stroke_paint_image,

            fill_paint_image,

        )?))

    }

    fn run_filters(

        &mut self,

        viewport: &Viewport,

        surface_to_filter: SharedImageSurface,

        filter: &Filter,

        acquired_nodes: &mut AcquiredNodes<'_>,

        node_name: &str,

        user_space_params: &NormalizeParams,

        stroke_paint_source: Rc<UserSpacePaintSource>,

        fill_paint_source: Rc<UserSpacePaintSource>,

        node_bbox: &BoundingBox,

    ) -> Result<SharedImageSurface, InternalRenderingError> {

        let session = self.session();

        // We try to convert each item in the filter_list to a FilterSpec.

        //

        // However, the spec mentions, "If the filter references a non-existent object or

        // the referenced object is not a filter element, then the whole filter chain is

        // ignored." - https://www.w3.org/TR/filter-effects/#FilterProperty

        //

        // So, run through the filter_list and collect into a Result<Vec<FilterSpec>>.

        // This will return an Err if any of the conversions failed.

        let filter_specs = filter

            .filter_list

            .iter()

            .map(|filter_value| {

                filter_value.to_filter_spec(

                    acquired_nodes,

                    user_space_params,

                    filter.current_color,

                    viewport,

                    session,

                    node_name,

                )

            })

            .collect::<Result<Vec<FilterSpec>, _>>();

        match filter_specs {

            Ok(specs) => {

                let plan = self.make_filter_plan(

                    acquired_nodes,

                    &specs,

                    surface_to_filter.width(),

                    surface_to_filter.height(),

                    stroke_paint_source,

                    fill_paint_source,

                    viewport,

                )?;

                specs.iter().try_fold(surface_to_filter, |surface, spec| {

                    filters::render(plan.clone(), spec, surface, acquired_nodes, self, node_bbox)

                })

            Err(e) => {

                rsvg_log!(

                    self.session,

                    "not rendering filter list on node {} because it was in error: {}",

                    node_name,

                    e

                );

                Ok(surface_to_filter)

    }

    fn set_pattern(

        &mut self,

        pattern: &UserSpacePattern,

        acquired_nodes: &mut AcquiredNodes<'_>,

        viewport: &Viewport,

    ) -> Result<bool, InternalRenderingError> {

        // Bail out early if the pattern has zero size, per the spec

        if approx_eq!(f64, pattern.width, 0.0) || approx_eq!(f64, pattern.height, 0.0) {

            return Ok(false);

        }

        let pattern_node_acquired = match pattern.acquire_pattern_node(acquired_nodes) {

            Ok(n) => n,

        let pattern_node = pattern_node_acquired.get();

        let taffine = viewport.transform.pre_transform(&pattern.transform);

        let mut scwscale = (taffine.xx.powi(2) + taffine.xy.powi(2)).sqrt();

        let mut schscale = (taffine.yx.powi(2) + taffine.yy.powi(2)).sqrt();

        let pw: i32 = (pattern.width * scwscale) as i32;

        let ph: i32 = (pattern.height * schscale) as i32;

        if pw < 1 || ph < 1 {

            return Ok(false);

        }

        scwscale = f64::from(pw) / pattern.width;

        schscale = f64::from(ph) / pattern.height;

        let (affine, caffine) = if scwscale.approx_eq_cairo(1.0) && schscale.approx_eq_cairo(1.0) {

            (pattern.coord_transform, pattern.content_transform)

            (

                pattern

                    .coord_transform

                    .pre_scale(1.0 / scwscale, 1.0 / schscale),

                pattern.content_transform.post_scale(scwscale, schscale),

            )

        let surface = self

            .cr

            .target()

            .create_similar(cairo::Content::ColorAlpha, pw, ph)?;

        let cr_pattern = cairo::Context::new(&surface)?;

        let transform = ValidTransform::try_from(caffine)?;

        cr_pattern.set_matrix(transform.into());

        // Draw everything

        {

            let mut pattern_draw_ctx = self.nested(cr_pattern);

            let pattern_viewport = viewport

                .with_view_box(pattern.width, pattern.height)

                .with_explicit_transform(transform);

            let pattern_cascaded = CascadedValues::new_from_node(pattern_node);

            let pattern_values = pattern_cascaded.get();

            let elt = pattern_node.borrow_element();

            let stacking_ctx = Box::new(StackingContext::new(

                self.session(),

                acquired_nodes,

                &elt,

                Transform::identity(),

                None,

                pattern_values,

            ));

            pattern_draw_ctx

                .with_alpha(pattern.opacity, &mut |dc| {

                    dc.with_discrete_layer(

                        &stacking_ctx,

                        acquired_nodes,

                        &pattern_viewport,

                        None,

                        false,

                        &mut |an, dc, new_viewport| {

                            pattern_node.draw_children(

                                an,

                                &pattern_cascaded,

                                new_viewport,

                                dc,

                                false,

                            )

                        },

                    )

                })

                .map(|_| ())?;

        let pattern = cairo::SurfacePattern::create(&surface);

        if let Some(m) = affine.invert() {

            pattern.set_matrix(ValidTransform::try_from(m)?.into());

            pattern.set_extend(cairo::Extend::Repeat);

            pattern.set_filter(cairo::Filter::Best);

            self.cr.set_source(&pattern)?;

        Ok(true)

    }

    fn set_paint_source(

        &mut self,

        paint_source: &UserSpacePaintSource,

        acquired_nodes: &mut AcquiredNodes<'_>,

        viewport: &Viewport,

    ) -> Result<bool, InternalRenderingError> {

        match *paint_source {

            UserSpacePaintSource::Gradient(ref gradient, _c) => {

                set_gradient_on_cairo(&self.cr, gradient)?;

                Ok(true)

            UserSpacePaintSource::Pattern(ref pattern, ref c) => {

                if self.set_pattern(pattern, acquired_nodes, viewport)? {

                    Ok(true)

                } else if let Some(c) = c {

                    set_source_color_on_cairo(&self.cr, c);

                    Ok(true)

                    Ok(false)

            UserSpacePaintSource::SolidColor(ref c) => {

                set_source_color_on_cairo(&self.cr, c);

                Ok(true)

            UserSpacePaintSource::None => Ok(false),

    }

    pub fn get_paint_source_surface(

        &mut self,

        width: i32,

        height: i32,

        acquired_nodes: &mut AcquiredNodes<'_>,

        paint_source: &UserSpacePaintSource,

        viewport: &Viewport,

    ) -> Result<SharedImageSurface, InternalRenderingError> {

        let mut surface = ExclusiveImageSurface::new(width, height, SurfaceType::SRgb)?;

        surface.draw(&mut |cr| {

            let mut temporary_draw_ctx = self.nested(cr);