Merge branch 'master' into virtual-widgets

graphics/src/widget/canvas.rs

@@ -211,6 +211,11 @@ where
         use iced_native::Renderer as _;
 
         let bounds = layout.bounds();
+
+        if bounds.width < 1.0 || bounds.height < 1.0 {
+            return;
+        }
+
         let translation = Vector::new(bounds.x, bounds.y);
         let cursor = Cursor::from_window_position(cursor_position);
 

graphics/src/widget/canvas/frame.rs

@@ -253,6 +253,27 @@ impl Frame {
         self.transforms.current = self.transforms.previous.pop().unwrap();
     }
 
+    /// 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]
+    pub fn with_clip(&mut self, region: Rectangle, f: impl FnOnce(&mut Frame)) {
+        let mut frame = Frame::new(region.size());
+
+        f(&mut frame);
+
+        self.primitives.push(Primitive::Clip {
+            bounds: region,
+            content: Box::new(Primitive::Translate {
+                translation: Vector::new(region.x, region.y),
+                content: Box::new(frame.into_geometry().into_primitive()),
+            }),
+        });
+    }
+
     /// Applies a translation to the current transform of the [`Frame`].
     #[inline]
     pub fn translate(&mut self, translation: Vector) {

native/src/user_interface.rs

@@ -345,30 +345,36 @@ where
 
         let viewport = Rectangle::with_size(self.bounds);
 
-        if let Some(layout) = &self.overlay {
+        let base_cursor = if let Some(overlay) =
-            let base_cursor = if layout.bounds().contains(cursor_position) {
+            self.root.overlay(Layout::new(&self.base), renderer)
-                Point::new(-1.0, -1.0)
+        {
-            } else {
+            let overlay_layout = self
-                cursor_position
+                .overlay
-            };
+                .take()
+                .unwrap_or_else(|| overlay.layout(renderer, self.bounds));
 
-            self.root.widget.draw(
+            let new_cursor_position =
-                renderer,
+                if overlay_layout.bounds().contains(cursor_position) {
-                &renderer::Style::default(),
+                    Point::new(-1.0, -1.0)
-                Layout::new(&self.base),
+                } else {
-                base_cursor,
+                    cursor_position
-                &viewport,
+                };
-            );
+
+            self.overlay = Some(overlay_layout);
+
+            new_cursor_position
         } else {
-            self.root.widget.draw(
+            cursor_position
-                renderer,
-                &renderer::Style::default(),
-                Layout::new(&self.base),
-                cursor_position,
-                &viewport,
-            );
         };
 
+        self.root.widget.draw(
+            renderer,
+            &renderer::Style::default(),
+            Layout::new(&self.base),
+            base_cursor,
+            &viewport,
+        );
+
         let base_interaction = self.root.widget.mouse_interaction(
             Layout::new(&self.base),
             cursor_position,