Restore `canvas::Frame` API

1 files changed, 7 insertions, 247 deletions

diff --git a/graphics/src/geometry.rs b/graphics/src/geometry.rs
index cd4c9267..2b18243e 100644
--- a/graphics/src/geometry.rs
+++ b/graphics/src/geometry.rs
@@ -1,12 +1,16 @@
 //! Build and draw geometry.
 pub mod fill;
+pub mod frame;
 pub mod path;
 pub mod stroke;
 
+mod cache;
 mod style;
 mod text;
 
+pub use cache::Cache;
 pub use fill::Fill;
+pub use frame::Frame;
 pub use path::Path;
 pub use stroke::{LineCap, LineDash, LineJoin, Stroke};
 pub use style::Style;
@@ -14,18 +18,7 @@ pub use text::Text;
 
 pub use crate::gradient::{self, Gradient};
 
-use crate::core::{Point, Radians, Rectangle, Size, Vector};
-use crate::Primitive;
-
-use std::cell::RefCell;
-use std::sync::Arc;
-
-pub fn frame<Renderer>(renderer: &Renderer, size: Size) -> Renderer::Frame
-where
-    Renderer: self::Renderer,
-{
-    renderer.new_frame(size)
-}
+use crate::core::Size;
 
 /// A renderer capable of drawing some [`Self::Geometry`].
 pub trait Renderer: crate::core::Renderer {
@@ -33,7 +26,7 @@ pub trait Renderer: crate::core::Renderer {
     type Geometry: Geometry;
 
     /// The kind of [`Frame`] this renderer supports.
-    type Frame: Frame<Geometry = Self::Geometry>;
+    type Frame: frame::Backend<Geometry = Self::Geometry>;
 
     fn new_frame(&self, size: Size) -> Self::Frame;
 
@@ -43,127 +36,11 @@ pub trait Renderer: crate::core::Renderer {
 
 pub trait Backend {
     /// The kind of [`Frame`] this backend supports.
-    type Frame: Frame;
+    type Frame: frame::Backend;
 
     fn new_frame(&self, size: Size) -> Self::Frame;
 }
 
-pub trait Frame: Sized + Into<Self::Geometry> {
-    /// The kind of geometry this frame can draw.
-    type Geometry: Geometry;
-
-    /// Returns the width of the [`Frame`].
-    fn width(&self) -> f32;
-
-    /// Returns the height of the [`Frame`].
-    fn height(&self) -> f32;
-
-    /// Returns the dimensions of the [`Frame`].
-    fn size(&self) -> Size;
-
-    /// Returns the coordinate of the center of the [`Frame`].
-    fn center(&self) -> Point;
-
-    /// Draws the given [`Path`] on the [`Frame`] by filling it with the
-    /// provided style.
-    fn fill(&mut self, path: &Path, fill: impl Into<Fill>);
-
-    /// Draws an axis-aligned rectangle given its top-left corner coordinate and
-    /// its `Size` on the [`Frame`] by filling it with the provided style.
-    fn fill_rectangle(
-        &mut self,
-        top_left: Point,
-        size: Size,
-        fill: impl Into<Fill>,
-    );
-
-    /// Draws the stroke of the given [`Path`] on the [`Frame`] with the
-    /// provided style.
-    fn stroke<'a>(&mut self, path: &Path, stroke: impl Into<Stroke<'a>>);
-
-    /// Draws the characters of the given [`Text`] on the [`Frame`], filling
-    /// them with the given color.
-    ///
-    /// __Warning:__ Text currently does not work well with rotations and scale
-    /// transforms! The position will be correctly transformed, but the
-    /// resulting glyphs will not be rotated or scaled properly.
-    ///
-    /// Additionally, all text will be rendered on top of all the layers of
-    /// a `Canvas`. Therefore, it is currently only meant to be used for
-    /// overlays, which is the most common use case.
-    ///
-    /// Support for vectorial text is planned, and should address all these
-    /// limitations.
-    fn fill_text(&mut self, text: impl Into<Text>);
-
-    /// Stores the current transform of the [`Frame`] and executes the given
-    /// drawing operations, restoring the transform afterwards.
-    ///
-    /// This method is useful to compose transforms and perform drawing
-    /// operations in different coordinate systems.
-    #[inline]
-    fn with_save<R>(&mut self, f: impl FnOnce(&mut Self) -> R) -> R {
-        self.push_transform();
-
-        let result = f(self);
-
-        self.pop_transform();
-
-        result
-    }
-
-    /// Pushes the current transform in the transform stack.
-    fn push_transform(&mut self);
-
-    /// Pops a transform from the transform stack and sets it as the current transform.
-    fn pop_transform(&mut self);
-
-    /// Executes the given drawing operations within a [`Rectangle`] region,
-    /// clipping any geometry that overflows its bounds. Any transformations
-    /// performed are local to the provided closure.
-    ///
-    /// This method is useful to perform drawing operations that need to be
-    /// clipped.
-    #[inline]
-    fn with_clip<R>(
-        &mut self,
-        region: Rectangle,
-        f: impl FnOnce(&mut Self) -> R,
-    ) -> R {
-        let mut frame = self.draft(region.size());
-
-        let result = f(&mut frame);
-
-        let origin = Point::new(region.x, region.y);
-
-        self.paste(frame, origin);
-
-        result
-    }
-
-    /// Creates a new [`Frame`] with the given [`Size`].
-    ///
-    /// Draw its contents back to this [`Frame`] with [`paste`].
-    ///
-    /// [`paste`]: Self::paste
-    fn draft(&mut self, size: Size) -> Self;
-
-    /// Draws the contents of the given [`Frame`] with origin at the given [`Point`].
-    fn paste(&mut self, frame: Self, at: Point);
-
-    /// Applies a translation to the current transform of the [`Frame`].
-    fn translate(&mut self, translation: Vector);
-
-    /// Applies a rotation in radians to the current transform of the [`Frame`].
-    fn rotate(&mut self, angle: impl Into<Radians>);
-
-    /// Applies a uniform scaling to the current transform of the [`Frame`].
-    fn scale(&mut self, scale: impl Into<f32>);
-
-    /// Applies a non-uniform scaling to the current transform of the [`Frame`].
-    fn scale_nonuniform(&mut self, scale: impl Into<Vector>);
-}
-
 pub trait Geometry: Sized {
     type Cache;
 
@@ -171,120 +48,3 @@ pub trait Geometry: Sized {
 
     fn cache(self) -> Self::Cache;
 }
-
-/// A simple cache that stores generated [`Geometry`] to avoid recomputation.
-///
-/// A [`Cache`] will not redraw its geometry unless the dimensions of its layer
-/// change or it is explicitly cleared.
-pub struct Cache<Renderer>
-where
-    Renderer: self::Renderer,
-{
-    state: RefCell<State<Renderer::Geometry>>,
-}
-
-impl<Renderer> Cache<Renderer>
-where
-    Renderer: self::Renderer,
-{
-    /// Creates a new empty [`Cache`].
-    pub fn new() -> Self {
-        Cache {
-            state: RefCell::new(State::Empty),
-        }
-    }
-
-    /// Clears the [`Cache`], forcing a redraw the next time it is used.
-    pub fn clear(&self) {
-        *self.state.borrow_mut() = State::Empty;
-    }
-
-    /// Draws [`Geometry`] using the provided closure and stores it in the
-    /// [`Cache`].
-    ///
-    /// The closure will only be called when
-    /// - the bounds have changed since the previous draw call.
-    /// - the [`Cache`] is empty or has been explicitly cleared.
-    ///
-    /// Otherwise, the previously stored [`Geometry`] will be returned. The
-    /// [`Cache`] is not cleared in this case. In other words, it will keep
-    /// returning the stored [`Geometry`] if needed.
-    pub fn draw(
-        &self,
-        renderer: &Renderer,
-        bounds: Size,
-        draw_fn: impl FnOnce(&mut Renderer::Frame),
-    ) -> Renderer::Geometry {
-        use std::ops::Deref;
-
-        if let State::Filled {
-            bounds: cached_bounds,
-            geometry,
-        } = self.state.borrow().deref()
-        {
-            if *cached_bounds == bounds {
-                return Geometry::load(geometry);
-            }
-        }
-
-        let mut frame = frame(renderer, bounds);
-        draw_fn(&mut frame);
-
-        let geometry = frame.into().cache();
-        let result = Geometry::load(&geometry);
-
-        *self.state.borrow_mut() = State::Filled { bounds, geometry };
-
-        result
-    }
-}
-
-impl<Renderer> std::fmt::Debug for Cache<Renderer>
-where
-    Renderer: self::Renderer,
-{
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        let state = self.state.borrow();
-
-        match *state {
-            State::Empty => write!(f, "Cache::Empty"),
-            State::Filled { bounds, .. } => {
-                write!(f, "Cache::Filled {{ bounds: {bounds:?} }}")
-            }
-        }
-    }
-}
-
-impl<Renderer> Default for Cache<Renderer>
-where
-    Renderer: self::Renderer,
-{
-    fn default() -> Self {
-        Self::new()
-    }
-}
-
-enum State<Geometry>
-where
-    Geometry: self::Geometry,
-{
-    Empty,
-    Filled {
-        bounds: Size,
-        geometry: Geometry::Cache,
-    },
-}
-
-impl<T> Geometry for Primitive<T> {
-    type Cache = Arc<Self>;
-
-    fn load(cache: &Arc<Self>) -> Self {
-        Self::Cache {
-            content: cache.clone(),
-        }
-    }
-
-    fn cache(self) -> Arc<Self> {
-        Arc::new(self)
-    }
-}