Restore canvas::Program API

examples/arc/src/main.rs

@@ -1,7 +1,9 @@
 use std::{f32::consts::PI, time::Instant};
 
 use iced::mouse;
-use iced::widget::canvas::{self, stroke, Cache, Canvas, Frame, Path, Stroke};
+use iced::widget::canvas::{
+    self, stroke, Cache, Canvas, Frame, Geometry, Path, Stroke,
+};
 use iced::{Element, Length, Point, Rectangle, Renderer, Subscription, Theme};
 
 pub fn main() -> iced::Result {
@@ -55,11 +57,11 @@ impl<Message> canvas::Program<Message> for Arc {
     fn draw(
         &self,
         _state: &Self::State,
-        renderer: &mut Renderer,
+        renderer: &Renderer,
         theme: &Theme,
         bounds: Rectangle,
         _cursor: mouse::Cursor,
-    ) {
+    ) -> Vec<Geometry> {
         let geometry = self.cache.draw(renderer, bounds.size(), |frame| {
             let palette = theme.palette();
 
@@ -102,6 +104,6 @@ impl<Message> canvas::Program<Message> for Arc {
             );
         });
 
-        renderer.draw_geometry([geometry]);
+        vec![geometry]
     }
 }

examples/bezier_tool/src/main.rs

@@ -52,7 +52,9 @@ impl Example {
 mod bezier {
     use iced::mouse;
     use iced::widget::canvas::event::{self, Event};
-    use iced::widget::canvas::{self, frame, Canvas, Frame, Path, Stroke};
+    use iced::widget::canvas::{
+        self, frame, Canvas, Frame, Geometry, Path, Stroke,
+    };
     use iced::{Element, Length, Point, Rectangle, Renderer, Theme};
 
     #[derive(Default)]
@@ -138,11 +140,11 @@ mod bezier {
         fn draw(
             &self,
             state: &Self::State,
-            renderer: &mut Renderer,
+            renderer: &Renderer,
             _theme: &Theme,
             bounds: Rectangle,
             cursor: mouse::Cursor,
-        ) {
+        ) -> Vec<Geometry> {
             let content =
                 self.state.cache.draw(renderer, bounds.size(), |frame| {
                     Curve::draw_all(self.curves, frame);
@@ -153,10 +155,10 @@ mod bezier {
                     );
                 });
 
-            renderer.draw_geometry([content]);
-
             if let Some(pending) = state {
-                pending.draw(renderer, bounds, cursor);
+                vec![content, pending.draw(renderer, bounds, cursor)]
+            } else {
+                vec![content]
             }
         }
 
@@ -203,10 +205,10 @@ mod bezier {
     impl Pending {
         fn draw(
             &self,
-            renderer: &mut Renderer,
+            renderer: &Renderer,
             bounds: Rectangle,
             cursor: mouse::Cursor,
-        ) {
+        ) -> Geometry {
             let mut frame = frame(renderer, bounds.size());
 
             if let Some(cursor_position) = cursor.position_in(bounds) {
@@ -227,7 +229,7 @@ mod bezier {
                 };
             }
 
-            renderer.draw_geometry([frame]);
+            frame.into()
         }
     }
 }

examples/clock/src/main.rs

@@ -1,6 +1,8 @@
 use iced::alignment;
 use iced::mouse;
-use iced::widget::canvas::{stroke, Cache, Frame, LineCap, Path, Stroke};
+use iced::widget::canvas::{
+    stroke, Cache, Frame, Geometry, LineCap, Path, Stroke,
+};
 use iced::widget::{canvas, container};
 use iced::{
     Degrees, Element, Font, Length, Point, Rectangle, Renderer, Subscription,
@@ -82,11 +84,11 @@ impl<Message> canvas::Program<Message> for Clock {
     fn draw(
         &self,
         _state: &Self::State,
-        renderer: &mut Renderer,
+        renderer: &Renderer,
         theme: &Theme,
         bounds: Rectangle,
         _cursor: mouse::Cursor,
-    ) {
+    ) -> Vec<Geometry> {
         let clock = self.clock.draw(renderer, bounds.size(), |frame| {
             let palette = theme.extended_palette();
 
@@ -163,7 +165,7 @@ impl<Message> canvas::Program<Message> for Clock {
             });
         });
 
-        renderer.draw_geometry([clock]);
+        vec![clock]
     }
 }
 

examples/color_palette/src/main.rs

@@ -1,6 +1,6 @@
 use iced::alignment::{self, Alignment};
 use iced::mouse;
-use iced::widget::canvas::{self, Canvas, Frame, Path};
+use iced::widget::canvas::{self, Canvas, Frame, Geometry, Path};
 use iced::widget::{column, row, text, Slider};
 use iced::{
     Color, Element, Font, Length, Pixels, Point, Rectangle, Renderer, Size,
@@ -252,18 +252,18 @@ impl<Message> canvas::Program<Message> for Theme {
     fn draw(
         &self,
         _state: &Self::State,
-        renderer: &mut Renderer,
+        renderer: &Renderer,
         theme: &iced::Theme,
         bounds: Rectangle,
         _cursor: mouse::Cursor,
-    ) {
+    ) -> Vec<Geometry> {
         let theme = self.canvas_cache.draw(renderer, bounds.size(), |frame| {
             let palette = theme.extended_palette();
 
             self.draw(frame, palette.background.base.text);
         });
 
-        renderer.draw_geometry([theme]);
+        vec![theme]
     }
 }
 

examples/game_of_life/src/main.rs

@@ -193,7 +193,9 @@ mod grid {
     use iced::touch;
     use iced::widget::canvas;
     use iced::widget::canvas::event::{self, Event};
-    use iced::widget::canvas::{frame, Cache, Canvas, Frame, Path, Text};
+    use iced::widget::canvas::{
+        frame, Cache, Canvas, Frame, Geometry, Path, Text,
+    };
     use iced::{
         Color, Element, Length, Point, Rectangle, Renderer, Size, Theme, Vector,
     };
@@ -516,11 +518,11 @@ mod grid {
         fn draw(
             &self,
             _interaction: &Interaction,
-            renderer: &mut Renderer,
+            renderer: &Renderer,
             _theme: &Theme,
             bounds: Rectangle,
             cursor: mouse::Cursor,
-        ) {
+        ) -> Vec<Geometry> {
             let center = Vector::new(bounds.width / 2.0, bounds.height / 2.0);
 
             let life = self.life_cache.draw(renderer, bounds.size(), |frame| {
@@ -638,9 +640,9 @@ mod grid {
                         }
                     });
 
-                renderer.draw_geometry([life, grid, overlay]);
+                vec![life, grid, overlay]
             } else {
-                renderer.draw_geometry([life, overlay]);
+                vec![life, overlay]
             }
         }
 

examples/layout/src/main.rs

@@ -292,11 +292,11 @@ fn square<'a>(size: impl Into<Length> + Copy) -> Element<'a, Message> {
         fn draw(
             &self,
             _state: &Self::State,
-            renderer: &mut Renderer,
+            renderer: &Renderer,
             theme: &Theme,
             bounds: Rectangle,
             _cursor: mouse::Cursor,
-        ) {
+        ) -> Vec<canvas::Geometry> {
             use canvas::Frame;
 
             let mut frame = canvas::frame(renderer, bounds.size());
@@ -309,7 +309,7 @@ fn square<'a>(size: impl Into<Length> + Copy) -> Element<'a, Message> {
                 palette.background.strong.color,
             );
 
-            renderer.draw_geometry([frame]);
+            vec![frame.into()]
         }
     }
 

examples/multitouch/src/main.rs

@@ -5,7 +5,7 @@ use iced::mouse;
 use iced::touch;
 use iced::widget::canvas::event;
 use iced::widget::canvas::stroke::{self, Stroke};
-use iced::widget::canvas::{self, Canvas};
+use iced::widget::canvas::{self, Canvas, Geometry};
 use iced::{Color, Element, Length, Point, Rectangle, Renderer, Theme};
 
 use std::collections::HashMap;
@@ -83,11 +83,11 @@ impl canvas::Program<Message> for Multitouch {
     fn draw(
         &self,
         _state: &Self::State,
-        renderer: &mut Renderer,
+        renderer: &Renderer,
         _theme: &Theme,
         bounds: Rectangle,
         _cursor: mouse::Cursor,
-    ) {
+    ) -> Vec<Geometry> {
         use canvas::Frame;
 
         let fingerweb = self.cache.draw(renderer, bounds.size(), |frame| {
@@ -156,6 +156,6 @@ impl canvas::Program<Message> for Multitouch {
             }
         });
 
-        renderer.draw_geometry([fingerweb]);
+        vec![fingerweb]
     }
 }

examples/sierpinski_triangle/src/main.rs

@@ -1,6 +1,6 @@
 use iced::mouse;
 use iced::widget::canvas::event::{self, Event};
-use iced::widget::canvas::{self, Canvas};
+use iced::widget::canvas::{self, Canvas, Geometry};
 use iced::widget::{column, row, slider, text};
 use iced::{Color, Length, Point, Rectangle, Renderer, Size, Theme};
 
@@ -107,11 +107,11 @@ impl canvas::Program<Message> for SierpinskiGraph {
     fn draw(
         &self,
         _state: &Self::State,
-        renderer: &mut Renderer,
+        renderer: &Renderer,
         _theme: &Theme,
         bounds: Rectangle,
         _cursor: mouse::Cursor,
-    ) {
+    ) -> Vec<Geometry> {
         use canvas::Frame;
 
         let geom = self.cache.draw(renderer, bounds.size(), |frame| {
@@ -141,7 +141,7 @@ impl canvas::Program<Message> for SierpinskiGraph {
             });
         });
 
-        renderer.draw_geometry([geom]);
+        vec![geom]
     }
 }
 

examples/solar_system/src/main.rs

@@ -10,7 +10,7 @@ use iced::mouse;
 use iced::widget::canvas;
 use iced::widget::canvas::gradient;
 use iced::widget::canvas::stroke::{self, Stroke};
-use iced::widget::canvas::Path;
+use iced::widget::canvas::{Geometry, Path};
 use iced::window;
 use iced::{
     Color, Element, Length, Point, Rectangle, Renderer, Size, Subscription,
@@ -126,11 +126,11 @@ impl<Message> canvas::Program<Message> for State {
     fn draw(
         &self,
         _state: &Self::State,
-        renderer: &mut Renderer,
+        renderer: &Renderer,
         _theme: &Theme,
         bounds: Rectangle,
         _cursor: mouse::Cursor,
-    ) {
+    ) -> Vec<Geometry> {
         use canvas::Frame;
         use std::f32::consts::PI;
 
@@ -198,7 +198,7 @@ impl<Message> canvas::Program<Message> for State {
             });
         });
 
-        renderer.draw_geometry([background, system]);
+        vec![background, system]
     }
 }
 

examples/vectorial_text/src/main.rs

@@ -124,11 +124,11 @@ impl<Message> canvas::Program<Message> for State {
     fn draw(
         &self,
         _state: &Self::State,
-        renderer: &mut Renderer,
+        renderer: &Renderer,
         theme: &Theme,
         bounds: Rectangle,
         _cursor: mouse::Cursor,
-    ) {
+    ) -> Vec<canvas::Geometry> {
         use canvas::Frame;
 
         let geometry = self.cache.draw(renderer, bounds.size(), |frame| {
@@ -155,7 +155,7 @@ impl<Message> canvas::Program<Message> for State {
             });
         });
 
-        renderer.draw_geometry([geometry]);
+        vec![geometry]
     }
 }
 

widget/src/canvas.rs

@@ -26,13 +26,17 @@ use std::marker::PhantomData;
 /// change or it is explicitly cleared.
 pub type Cache<Renderer = crate::Renderer> = geometry::Cache<Renderer>;
 
+/// The geometry supported by a renderer.
+pub type Geometry<Renderer = crate::Renderer> =
+    <Renderer as geometry::Renderer>::Geometry;
+
 /// A widget capable of drawing 2D graphics.
 ///
 /// ## Drawing a simple circle
 /// If you want to get a quick overview, here's how we can draw a simple circle:
 ///
 /// ```no_run
-/// # use iced_widget::canvas::{self, frame, Canvas, Fill, Frame, Path, Program};
+/// # use iced_widget::canvas::{self, frame, Canvas, Fill, Frame, Geometry, Path, Program};
 /// # use iced_widget::core::{Color, Rectangle};
 /// # use iced_widget::core::mouse;
 /// # use iced_widget::{Renderer, Theme};
@@ -47,7 +51,7 @@ pub type Cache<Renderer = crate::Renderer> = geometry::Cache<Renderer>;
 /// impl Program<()> for Circle {
 ///     type State = ();
 ///
-///     fn draw(&self, _state: &(), renderer: &mut Renderer, _theme: &Theme, bounds: Rectangle, _cursor: mouse::Cursor) {
+///     fn draw(&self, _state: &(), renderer: &Renderer, _theme: &Theme, bounds: Rectangle, _cursor: mouse::Cursor) -> Vec<Geometry> {
 ///         // We prepare a new `Frame`
 ///         let mut frame = frame(renderer, bounds.size());
 ///
@@ -58,7 +62,7 @@ pub type Cache<Renderer = crate::Renderer> = geometry::Cache<Renderer>;
 ///         frame.fill(&circle, Color::BLACK);
 ///
 ///         // Finally, we produce the geometry
-///         renderer.draw_geometry([frame]);
+///         vec![frame.into()]
 ///     }
 /// }
 ///
@@ -215,7 +219,12 @@ where
         renderer.with_transformation(
             Transformation::translate(bounds.x, bounds.y),
             |renderer| {
-                self.program.draw(state, renderer, theme, bounds, cursor);
+                let layers =
+                    self.program.draw(state, renderer, theme, bounds, cursor);
+
+                for layer in layers {
+                    renderer.draw_geometry(layer);
+                }
             },
         );
     }

widget/src/canvas/program.rs

@@ -1,5 +1,6 @@
 use crate::canvas::event::{self, Event};
 use crate::canvas::mouse;
+use crate::canvas::Geometry;
 use crate::core::Rectangle;
 use crate::graphics::geometry;
 
@@ -41,11 +42,11 @@ where
     fn draw(
         &self,
         state: &Self::State,
-        renderer: &mut Renderer,
+        renderer: &Renderer,
         theme: &Theme,
         bounds: Rectangle,
         cursor: mouse::Cursor,
-    );
+    ) -> Vec<Geometry<Renderer>>;
 
     /// Returns the current mouse interaction of the [`Program`].
     ///
@@ -83,12 +84,12 @@ where
     fn draw(
         &self,
         state: &Self::State,
-        renderer: &mut Renderer,
+        renderer: &Renderer,
         theme: &Theme,
         bounds: Rectangle,
         cursor: mouse::Cursor,
-    ) {
+    ) -> Vec<Geometry<Renderer>> {
-        T::draw(self, state, renderer, theme, bounds, cursor);
+        T::draw(self, state, renderer, theme, bounds, cursor)
     }
 
     fn mouse_interaction(