Fix Image::bounds when rotation present in iced_graphics

core/src/rectangle.rs

@@ -1,6 +1,6 @@
-use crate::{Point, Size, Vector};
+use crate::{Point, Radians, Size, Vector};
 
-/// A rectangle.
+/// An axis-aligned rectangle.
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
 pub struct Rectangle<T = f32> {
     /// X coordinate of the top-left corner.
@@ -172,6 +172,18 @@ impl Rectangle<f32> {
             height: self.height + amount * 2.0,
         }
     }
+
+    /// Rotates the [`Rectangle`] and returns the smallest [`Rectangle`]
+    /// containing it.
+    pub fn rotate(self, rotation: Radians) -> Self {
+        let size = self.size().rotate(rotation);
+        let position = Point::new(
+            self.center_x() - size.width / 2.0,
+            self.center_y() - size.height / 2.0,
+        );
+
+        Self::new(position, size)
+    }
 }
 
 impl std::ops::Mul<f32> for Rectangle<f32> {

core/src/rotation.rs

@@ -36,20 +36,12 @@ impl Rotation {
         Degrees(self.radians().0.to_degrees())
     }
 
-    /// Rotates the given [`Size`].
+    /// Applies the [`Rotation`] to the given [`Size`], returning
+    /// the minimum [`Size`] containing the rotated one.
     pub fn apply(self, size: Size) -> Size {
         match self {
             Self::Floating(_) => size,
-            Self::Solid(rotation) => {
-                let radians = f32::from(rotation);
-
-                Size {
-                    width: (size.width * radians.cos()).abs()
-                        + (size.height * radians.sin()).abs(),
-                    height: (size.width * radians.sin()).abs()
-                        + (size.height * radians.cos()).abs(),
-                }
-            }
+            Self::Solid(rotation) => size.rotate(rotation),
         }
     }
 }

core/src/size.rs

@@ -1,4 +1,4 @@
-use crate::Vector;
+use crate::{Radians, Vector};
 
 /// An amount of space in 2 dimensions.
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Default)]
@@ -51,6 +51,19 @@ impl Size {
             height: self.height + other.height,
         }
     }
+
+    /// Rotates the given [`Size`] and returns the minimum [`Size`]
+    /// containing it.
+    pub fn rotate(self, rotation: Radians) -> Size {
+        let radians = f32::from(rotation);
+
+        Size {
+            width: (self.width * radians.cos()).abs()
+                + (self.height * radians.sin()).abs(),
+            height: (self.width * radians.sin()).abs()
+                + (self.height * radians.cos()).abs(),
+        }
+    }
 }
 
 impl<T> From<[T; 2]> for Size<T> {