Decouple the image Handle type from the iced_native implementation

graphics/src/widget/image.rs

@@ -13,6 +13,8 @@ impl<B> image::Renderer for Renderer<B>
 where
     B: Backend + backend::Image,
 {
+    type Handle = image::Handle;
+
     fn dimensions(&self, handle: &image::Handle) -> (u32, u32) {
         self.backend().dimensions(handle)
     }

native/src/image.rs

@@ -115,10 +115,15 @@ impl std::fmt::Debug for Data {
 ///
 /// [renderer]: crate::renderer
 pub trait Renderer: crate::Renderer {
+    /// The image Handle to be displayed. Iced exposes its own default implementation of a [`Handle`]
+    ///
+    /// [`Handle`]: Self::Handle
+    type Handle: Clone + Hash;
+
     /// Returns the dimensions of an image for the given [`Handle`].
-    fn dimensions(&self, handle: &Handle) -> (u32, u32);
+    fn dimensions(&self, handle: &Self::Handle) -> (u32, u32);
 
     /// Draws an image with the given [`Handle`] and inside the provided
     /// `bounds`.
-    fn draw(&mut self, handle: Handle, bounds: Rectangle);
+    fn draw(&mut self, handle: Self::Handle, bounds: Rectangle);
 }

native/src/widget/image.rs

@@ -2,7 +2,7 @@
 pub mod viewer;
 pub use viewer::Viewer;
 
-use crate::image::{self, Handle};
+use crate::image;
 use crate::layout;
 use crate::renderer;
 use crate::{Element, Hasher, Layout, Length, Point, Rectangle, Size, Widget};
@@ -15,19 +15,20 @@ use std::hash::Hash;
 ///
 /// ```
 /// # use iced_native::widget::Image;
+/// # use iced_native::image;
 /// #
-/// let image = Image::new("resources/ferris.png");
+/// let image = Image::<image::Handle>::new("resources/ferris.png");
 /// ```
 ///
 /// <img src="https://github.com/hecrj/iced/blob/9712b319bb7a32848001b96bd84977430f14b623/examples/resources/ferris.png?raw=true" width="300">
 #[derive(Debug, Hash)]
-pub struct Image {
+pub struct Image<Handle> {
     handle: Handle,
     width: Length,
     height: Length,
 }
 
-impl Image {
+impl<Handle> Image<Handle> {
     /// Creates a new [`Image`] with the given path.
     pub fn new<T: Into<Handle>>(handle: T) -> Self {
         Image {
@@ -50,9 +51,10 @@ impl Image {
     }
 }
 
-impl<Message, Renderer> Widget<Message, Renderer> for Image
+impl<Message, Renderer, Handle> Widget<Message, Renderer> for Image<Handle>
 where
-    Renderer: image::Renderer,
+    Renderer: image::Renderer<Handle = Handle>,
+    Handle: Clone + Hash,
 {
     fn width(&self) -> Length {
         self.width
@@ -108,11 +110,13 @@ where
     }
 }
 
-impl<'a, Message, Renderer> From<Image> for Element<'a, Message, Renderer>
+impl<'a, Message, Renderer, Handle> From<Image<Handle>>
+    for Element<'a, Message, Renderer>
 where
-    Renderer: image::Renderer,
+    Renderer: image::Renderer<Handle = Handle>,
+    Handle: Clone + Hash + 'a,
 {
-    fn from(image: Image) -> Element<'a, Message, Renderer> {
+    fn from(image: Image<Handle>) -> Element<'a, Message, Renderer> {
         Element::new(image)
     }
 }

native/src/widget/image/viewer.rs

@@ -13,7 +13,7 @@ use std::hash::Hash;
 
 /// A frame that displays an image with the ability to zoom in/out and pan.
 #[allow(missing_debug_implementations)]
-pub struct Viewer<'a> {
+pub struct Viewer<'a, Handle> {
     state: &'a mut State,
     padding: u16,
     width: Length,
@@ -21,14 +21,12 @@ pub struct Viewer<'a> {
     min_scale: f32,
     max_scale: f32,
     scale_step: f32,
-    handle: image::Handle,
+    handle: Handle,
 }
 
-impl<'a> Viewer<'a> {
-    /// Creates a new [`Viewer`] with the given [`State`] and [`Handle`].
-    ///
-    /// [`Handle`]: image::Handle
-    pub fn new(state: &'a mut State, handle: image::Handle) -> Self {
+impl<'a, Handle> Viewer<'a, Handle> {
+    /// Creates a new [`Viewer`] with the given [`State`].
+    pub fn new(state: &'a mut State, handle: Handle) -> Self {
         Viewer {
             state,
             padding: 0,
@@ -89,7 +87,7 @@ impl<'a> Viewer<'a> {
     /// will be respected.
     fn image_size<Renderer>(&self, renderer: &Renderer, bounds: Size) -> Size
     where
-        Renderer: image::Renderer,
+        Renderer: image::Renderer<Handle = Handle>,
     {
         let (width, height) = renderer.dimensions(&self.handle);
 
@@ -114,9 +112,11 @@ impl<'a> Viewer<'a> {
     }
 }
 
-impl<'a, Message, Renderer> Widget<Message, Renderer> for Viewer<'a>
+impl<'a, Message, Renderer, Handle> Widget<Message, Renderer>
+    for Viewer<'a, Handle>
 where
-    Renderer: image::Renderer,
+    Renderer: image::Renderer<Handle = Handle>,
+    Handle: Clone + Hash,
 {
     fn width(&self) -> Length {
         self.width
@@ -394,12 +394,14 @@ impl State {
     }
 }
 
-impl<'a, Message, Renderer> From<Viewer<'a>> for Element<'a, Message, Renderer>
+impl<'a, Message, Renderer, Handle> From<Viewer<'a, Handle>>
+    for Element<'a, Message, Renderer>
 where
-    Renderer: 'a + image::Renderer,
+    Renderer: 'a + image::Renderer<Handle = Handle>,
     Message: 'a,
+    Handle: Clone + Hash + 'a,
 {
-    fn from(viewer: Viewer<'a>) -> Element<'a, Message, Renderer> {
+    fn from(viewer: Viewer<'a, Handle>) -> Element<'a, Message, Renderer> {
         Element::new(viewer)
     }
 }