Refactor some `image` traits a bit

- Use `Size<u32>` were applicable.
- Rename `TextureStore` to `image::Storage`.
- Rename `TextureStoreEntry` to `image::storage::Entry`.
- Wire up `viewport_dimensions` to `iced_glow` for `Svg`.

3 files changed, 58 insertions, 21 deletions

diff --git a/graphics/src/image/raster.rs b/graphics/src/image/raster.rs
index f9672dd5..8ed9615d 100644
--- a/graphics/src/image/raster.rs
+++ b/graphics/src/image/raster.rs
@@ -1,15 +1,15 @@
-//! Raster image loading and caching
+//! Raster image loading and caching.
+use crate::image::Storage;
+use crate::Size;
 
 use iced_native::image;
-use std::collections::{HashMap, HashSet};
 
 use bitflags::bitflags;
-
-use super::{TextureStore, TextureStoreEntry};
+use std::collections::{HashMap, HashSet};
 
 /// Entry in cache corresponding to an image handle
 #[derive(Debug)]
-pub enum Memory<T: TextureStore> {
+pub enum Memory<T: Storage> {
     /// Image data on host
     Host(::image_rs::ImageBuffer<::image_rs::Rgba<u8>, Vec<u8>>),
     /// Texture store entry
@@ -20,26 +20,32 @@ pub enum Memory<T: TextureStore> {
     Invalid,
 }
 
-impl<T: TextureStore> Memory<T> {
+impl<T: Storage> Memory<T> {
     /// Width and height of image
-    pub fn dimensions(&self) -> (u32, u32) {
+    pub fn dimensions(&self) -> Size<u32> {
+        use crate::image::storage::Entry;
+
         match self {
-            Memory::Host(image) => image.dimensions(),
+            Memory::Host(image) => {
+                let (width, height) = image.dimensions();
+
+                Size::new(width, height)
+            }
             Memory::Device(entry) => entry.size(),
-            Memory::NotFound => (1, 1),
-            Memory::Invalid => (1, 1),
+            Memory::NotFound => Size::new(1, 1),
+            Memory::Invalid => Size::new(1, 1),
         }
     }
 }
 
 /// Caches image raster data
 #[derive(Debug)]
-pub struct Cache<T: TextureStore> {
+pub struct Cache<T: Storage> {
     map: HashMap<u64, Memory<T>>,
     hits: HashSet<u64>,
 }
 
-impl<T: TextureStore> Cache<T> {
+impl<T: Storage> Cache<T> {
     /// Load image
     pub fn load(&mut self, handle: &image::Handle) -> &mut Memory<T> {
         if self.contains(handle) {
@@ -153,7 +159,7 @@ impl<T: TextureStore> Cache<T> {
     }
 }
 
-impl<T: TextureStore> Default for Cache<T> {
+impl<T: Storage> Default for Cache<T> {
     fn default() -> Self {
         Self {
             map: HashMap::new(),
diff --git a/graphics/src/image/storage.rs b/graphics/src/image/storage.rs
new file mode 100644
index 00000000..2098c7b2
--- /dev/null
+++ b/graphics/src/image/storage.rs
@@ -0,0 +1,31 @@
+//! Store images.
+use crate::Size;
+
+use std::fmt::Debug;
+
+/// Stores cached image data for use in rendering
+pub trait Storage {
+    /// The type of an [`Entry`] in the [`Storage`].
+    type Entry: Entry;
+
+    /// State provided to upload or remove a [`Self::Entry`].
+    type State<'a>;
+
+    /// Upload the image data of a [`Self::Entry`].
+    fn upload(
+        &mut self,
+        width: u32,
+        height: u32,
+        data: &[u8],
+        state: &mut Self::State<'_>,
+    ) -> Option<Self::Entry>;
+
+    /// Romve a [`Self::Entry`] from the [`Storage`].
+    fn remove(&mut self, entry: &Self::Entry, state: &mut Self::State<'_>);
+}
+
+/// An entry in some [`Storage`],
+pub trait Entry: Debug {
+    /// The [`Size`] of the [`Entry`].
+    fn size(&self) -> Size<u32>;
+}
diff --git a/graphics/src/image/vector.rs b/graphics/src/image/vector.rs
index 0062e2ce..818fdd20 100644
--- a/graphics/src/image/vector.rs
+++ b/graphics/src/image/vector.rs
@@ -1,12 +1,12 @@
 //! Vector image loading and caching
+use crate::image::Storage;
 
 use iced_native::svg;
+use iced_native::Size;
 
 use std::collections::{HashMap, HashSet};
 use std::fs;
 
-use super::TextureStore;
-
 /// Entry in cache corresponding to an svg handle
 pub enum Svg {
     /// Parsed svg
@@ -17,28 +17,28 @@ pub enum Svg {
 
 impl Svg {
     /// Viewport width and height
-    pub fn viewport_dimensions(&self) -> (u32, u32) {
+    pub fn viewport_dimensions(&self) -> Size<u32> {
         match self {
             Svg::Loaded(tree) => {
                 let size = tree.svg_node().size;
 
-                (size.width() as u32, size.height() as u32)
+                Size::new(size.width() as u32, size.height() as u32)
             }
-            Svg::NotFound => (1, 1),
+            Svg::NotFound => Size::new(1, 1),
         }
     }
 }
 
 /// Caches svg vector and raster data
 #[derive(Debug)]
-pub struct Cache<T: TextureStore> {
+pub struct Cache<T: Storage> {
     svgs: HashMap<u64, Svg>,
     rasterized: HashMap<(u64, u32, u32), T::Entry>,
     svg_hits: HashSet<u64>,
     rasterized_hits: HashSet<(u64, u32, u32)>,
 }
 
-impl<T: TextureStore> Cache<T> {
+impl<T: Storage> Cache<T> {
     /// Load svg
     pub fn load(&mut self, handle: &svg::Handle) -> &Svg {
         if self.svgs.contains_key(&handle.id()) {
@@ -162,7 +162,7 @@ impl<T: TextureStore> Cache<T> {
     }
 }
 
-impl<T: TextureStore> Default for Cache<T> {
+impl<T: Storage> Default for Cache<T> {
     fn default() -> Self {
         Self {
             svgs: HashMap::new(),