Help on implementing "Image" variant for iced::core::Background

[gabrieldechichi]

Hi,

I'd like to implement the Image variant for iced::core::Background and would like to ask the community for suggestions on the best way to approach it.

/// The background of some element.
#[derive(Debug, Clone, Copy, PartialEq)]
pub enum Background {
    /// A solid color
    Color(Color),
    // TODO: Add gradient and image variants
}

The immediate problem is that Background is defined on core whereas image is defined in native (which depends on core), so we can't add a direct reference to native::image::Image or native::image::Handle here.

Is the best approach to create a generic Image<Handle> struct inside core, and have Background be generic as well? Then implementations on the native crate can require `impl Intoimage::Handle or something.

Something like this:

core/image.rs

#[derive(Debug, Copy, Clone, PartialEq)]
pub struct Image<Handle> {
    handle: Handle,
    width: Length,
    height: Length,
    content_fit: ContentFit,
}

core/background.rs

/// The background of some element.
#[derive(Debug, Clone, Copy, PartialEq)]
pub enum Background<Handle = ()> {
    /// A solid color
    Color(Color),
    Image(Image<Handle>)
    // TODO: Add gradient and image variants
}

Then handle the Image case here
graphis/src/renderer.rs

    fn fill_quad(
        &mut self,
        quad: renderer::Quad,
        background: impl Into<Background>,
    ) {
        let bg = background.into();
        match bg {
            Background::Color(c) => {
                self.primitives.push(Primitive::Quad {
                    bounds: quad.bounds,
                    background: background.into(),
                    border_radius: quad.border_radius.into(),
                    border_width: quad.border_width,
                    border_color: quad.border_color,
                });
            }
            Background::Image(img) => todo!(),
        }
    }

Any suggestions?