Introduce `Image` struct in `core::image`

3 files changed, 74 insertions, 20 deletions

diff --git a/core/src/image.rs b/core/src/image.rs
index 77ff7500..99d7f3ef 100644
--- a/core/src/image.rs
+++ b/core/src/image.rs
@@ -7,6 +7,73 @@ use rustc_hash::FxHasher;
 use std::hash::{Hash, Hasher};
 use std::path::{Path, PathBuf};
 
+/// A raster image that can be drawn.
+#[derive(Debug, Clone, PartialEq)]
+pub struct Image<H = Handle> {
+    /// The handle of the image.
+    pub handle: H,
+
+    /// The filter method of the image.
+    pub filter_method: FilterMethod,
+
+    /// The rotation to be applied to the image, from its center.
+    pub rotation: Radians,
+
+    /// The opacity of the image.
+    ///
+    /// 0 means transparent. 1 means opaque.
+    pub opacity: f32,
+
+    /// If set to `true`, the image will be snapped to the pixel grid.
+    ///
+    /// This can avoid graphical glitches, specially when using a
+    /// [`FilterMethod::Nearest`].
+    pub snap: bool,
+}
+
+impl Image<Handle> {
+    /// Creates a new [`Image`] with the given handle.
+    pub fn new(handle: impl Into<Handle>) -> Self {
+        Self {
+            handle: handle.into(),
+            filter_method: FilterMethod::default(),
+            rotation: Radians(0.0),
+            opacity: 1.0,
+            snap: false,
+        }
+    }
+
+    /// Sets the filter method of the [`Image`].
+    pub fn filter_method(mut self, filter_method: FilterMethod) -> Self {
+        self.filter_method = filter_method;
+        self
+    }
+
+    /// Sets the rotation of the [`Image`].
+    pub fn rotation(mut self, rotation: impl Into<Radians>) -> Self {
+        self.rotation = rotation.into();
+        self
+    }
+
+    /// Sets the opacity of the [`Image`].
+    pub fn opacity(mut self, opacity: impl Into<f32>) -> Self {
+        self.opacity = opacity.into();
+        self
+    }
+
+    /// Sets whether the [`Image`] should be snapped to the pixel grid.
+    pub fn snap(mut self, snap: bool) -> Self {
+        self.snap = snap;
+        self
+    }
+}
+
+impl From<&Handle> for Image {
+    fn from(handle: &Handle) -> Self {
+        Image::new(handle.clone())
+    }
+}
+
 /// A handle of some image data.
 #[derive(Clone, PartialEq, Eq)]
 pub enum Handle {
@@ -172,14 +239,6 @@ pub trait Renderer: crate::Renderer {
     /// Returns the dimensions of an image for the given [`Handle`].
     fn measure_image(&self, handle: &Self::Handle) -> Size<u32>;
 
-    /// Draws an image with the given [`Handle`] and inside the provided
-    /// `bounds`.
-    fn draw_image(
-        &mut self,
-        handle: Self::Handle,
-        filter_method: FilterMethod,
-        bounds: Rectangle,
-        rotation: Radians,
-        opacity: f32,
-    );
+    /// Draws an [`Image`] inside the provided `bounds`.
+    fn draw_image(&mut self, image: Image<Self::Handle>, bounds: Rectangle);
 }
diff --git a/core/src/lib.rs b/core/src/lib.rs
index 40a288e5..0e17d430 100644
--- a/core/src/lib.rs
+++ b/core/src/lib.rs
@@ -57,6 +57,7 @@ pub use element::Element;
 pub use event::Event;
 pub use font::Font;
 pub use gradient::Gradient;
+pub use image::Image;
 pub use layout::Layout;
 pub use length::Length;
 pub use overlay::Overlay;
diff --git a/core/src/renderer/null.rs b/core/src/renderer/null.rs
index 5c7513c6..e71117da 100644
--- a/core/src/renderer/null.rs
+++ b/core/src/renderer/null.rs
@@ -1,5 +1,5 @@
 use crate::alignment;
-use crate::image;
+use crate::image::{self, Image};
 use crate::renderer::{self, Renderer};
 use crate::svg;
 use crate::text::{self, Text};
@@ -178,20 +178,14 @@ impl text::Editor for () {
 }
 
 impl image::Renderer for () {
-    type Handle = ();
+    type Handle = image::Handle;
 
     fn measure_image(&self, _handle: &Self::Handle) -> Size<u32> {
         Size::default()
     }
 
-    fn draw_image(
-        &mut self,
-        _handle: Self::Handle,
-        _filter_method: image::FilterMethod,
-        _bounds: Rectangle,
-        _rotation: Radians,
-        _opacity: f32,
-    ) {
+    fn draw_image(&mut self, _image: Image, _bounds: Rectangle) {
+        todo!()
     }
 }