Implement event capturing for `Canvas`

examples/bezier_tool/src/main.rs

@@ -69,7 +69,8 @@ impl Sandbox for Example {
 
 mod bezier {
     use iced::{
-        canvas::{self, Canvas, Cursor, Event, Frame, Geometry, Path, Stroke},
+        canvas::event::{self, Event},
+        canvas::{self, Canvas, Cursor, Frame, Geometry, Path, Stroke},
         mouse, Element, Length, Point, Rectangle,
     };
 
@@ -109,17 +110,24 @@ mod bezier {
             event: Event,
             bounds: Rectangle,
             cursor: Cursor,
-        ) -> Option<Curve> {
-            let cursor_position = cursor.position_in(&bounds)?;
+        ) -> (event::Status, Option<Curve>) {
+            let cursor_position =
+                if let Some(position) = cursor.position_in(&bounds) {
+                    position
+                } else {
+                    return (event::Status::Ignored, None);
+                };
 
             match event {
-                Event::Mouse(mouse_event) => match mouse_event {
+                Event::Mouse(mouse_event) => {
+                    let message = match mouse_event {
                         mouse::Event::ButtonPressed(mouse::Button::Left) => {
                             match self.state.pending {
                                 None => {
                                     self.state.pending = Some(Pending::One {
                                         from: cursor_position,
                                     });
+
                                     None
                                 }
                                 Some(Pending::One { from }) => {
@@ -142,8 +150,11 @@ mod bezier {
                             }
                         }
                         _ => None,
-                },
-                _ => None,
+                    };
+
+                    (event::Status::Captured, message)
+                }
+                _ => (event::Status::Ignored, None),
             }
         }
 

examples/game_of_life/src/main.rs

@@ -153,9 +153,8 @@ impl Application for GameOfLife {
 mod grid {
     use crate::Preset;
     use iced::{
-        canvas::{
-            self, Cache, Canvas, Cursor, Event, Frame, Geometry, Path, Text,
-        },
+        canvas::event::{self, Event},
+        canvas::{self, Cache, Canvas, Cursor, Frame, Geometry, Path, Text},
         mouse, Color, Element, HorizontalAlignment, Length, Point, Rectangle,
         Size, Vector, VerticalAlignment,
     };
@@ -328,12 +327,18 @@ mod grid {
             event: Event,
             bounds: Rectangle,
             cursor: Cursor,
-        ) -> Option<Message> {
+        ) -> (event::Status, Option<Message>) {
             if let Event::Mouse(mouse::Event::ButtonReleased(_)) = event {
                 self.interaction = Interaction::None;
             }
 
-            let cursor_position = cursor.position_in(&bounds)?;
+            let cursor_position =
+                if let Some(position) = cursor.position_in(&bounds) {
+                    position
+                } else {
+                    return (event::Status::Ignored, None);
+                };
+
             let cell = Cell::at(self.project(cursor_position, bounds.size()));
             let is_populated = self.state.contains(&cell);
 
@@ -345,7 +350,8 @@ mod grid {
 
             match event {
                 Event::Mouse(mouse_event) => match mouse_event {
-                    mouse::Event::ButtonPressed(button) => match button {
+                    mouse::Event::ButtonPressed(button) => {
+                        let message = match button {
                             mouse::Button::Left => {
                                 self.interaction = if is_populated {
                                     Interaction::Erasing
@@ -364,9 +370,12 @@ mod grid {
                                 None
                             }
                             _ => None,
-                    },
+                        };
+
+                        (event::Status::Captured, message)
+                    }
                     mouse::Event::CursorMoved { .. } => {
-                        match self.interaction {
+                        let message = match self.interaction {
                             Interaction::Drawing => populate,
                             Interaction::Erasing => unpopulate,
                             Interaction::Panning { translation, start } => {
@@ -380,7 +389,14 @@ mod grid {
                                 None
                             }
                             _ => None,
-                        }
+                        };
+
+                        let event_status = match self.interaction {
+                            Interaction::None => event::Status::Ignored,
+                            _ => event::Status::Captured,
+                        };
+
+                        (event_status, message)
                     }
                     mouse::Event::WheelScrolled { delta } => match delta {
                         mouse::ScrollDelta::Lines { y, .. }
@@ -413,12 +429,12 @@ mod grid {
                                 self.grid_cache.clear();
                             }
 
-                            None
+                            (event::Status::Captured, None)
                         }
                     },
-                    _ => None,
+                    _ => (event::Status::Ignored, None),
                 },
-                _ => None,
+                _ => (event::Status::Ignored, None),
             }
         }
 

graphics/src/widget/canvas.rs

@@ -16,11 +16,11 @@ use iced_native::{
 use std::hash::Hash;
 use std::marker::PhantomData;
 
+pub mod event;
 pub mod path;
 
 mod cache;
 mod cursor;
-mod event;
 mod fill;
 mod frame;
 mod geometry;
@@ -184,11 +184,14 @@ where
         let cursor = Cursor::from_window_position(cursor_position);
 
         if let Some(canvas_event) = canvas_event {
-            if let Some(message) =
-                self.program.update(canvas_event, bounds, cursor)
-            {
+            let (event_status, message) =
+                self.program.update(canvas_event, bounds, cursor);
+
+            if let Some(message) = message {
                 messages.push(message);
             }
+
+            return event_status;
         }
 
         event::Status::Ignored

graphics/src/widget/canvas/event.rs

@@ -1,3 +1,4 @@
+//! Handle events of a canvas.
 use iced_native::keyboard;
 use iced_native::mouse;
 

graphics/src/widget/canvas/program.rs

@@ -1,4 +1,5 @@
-use crate::canvas::{Cursor, Event, Geometry};
+use crate::canvas::event::{self, Event};
+use crate::canvas::{Cursor, Geometry};
 use iced_native::{mouse, Rectangle};
 
 /// The state and logic of a [`Canvas`].
@@ -27,8 +28,8 @@ pub trait Program<Message> {
         _event: Event,
         _bounds: Rectangle,
         _cursor: Cursor,
-    ) -> Option<Message> {
-        None
+    ) -> (event::Status, Option<Message>) {
+        (event::Status::Ignored, None)
     }
 
     /// Draws the state of the [`Program`], producing a bunch of [`Geometry`].
@@ -67,7 +68,7 @@ where
         event: Event,
         bounds: Rectangle,
         cursor: Cursor,
-    ) -> Option<Message> {
+    ) -> (event::Status, Option<Message>) {
         T::update(self, event, bounds, cursor)
     }