Add Viewport up/down scroll

src/tool.rs

@@ -68,21 +68,25 @@ impl CanvasToolCtx {
 
     pub fn handle_event(
         &mut self,
-        mut ctx: &mut EventCtx,
+        ctx: &EventCtx,
         event: &Event,
         mut vcanvas: &mut VersionedCanvas,
         transform: Affine,
         env: &Env,
     ) {
         match self.initial_params.tool_type() {
-            CanvasToolType::Pen => self.handle_pen_event(ctx, event, vcanvas, transform, env),
-            CanvasToolType::Eraser => self.handle_erase_event(ctx, event, vcanvas, transform, env),
+            CanvasToolType::Pen => {
+                self.handle_pen_event(&ctx, &event, &mut vcanvas, transform, &env)
+            }
+            CanvasToolType::Eraser => {
+                self.handle_erase_event(&ctx, &event, &mut vcanvas, transform, &env)
+            }
         }
     }
 
     pub fn handle_erase_event(
         &mut self,
-        ctx: &mut EventCtx,
+        _ctx: &EventCtx,
         event: &Event,
         vcanvas: &mut VersionedCanvas,
         transform: Affine,
@@ -91,7 +95,6 @@ impl CanvasToolCtx {
         match (&mut self.state, event) {
             (CanvasToolState::Idle, Event::MouseDown(_)) => {
                 self.state = CanvasToolState::Erasing;
-                ctx.set_handled();
             }
             (CanvasToolState::Erasing, Event::MouseMove(mouse_event)) => {
                 let eraser_rect =
@@ -105,18 +108,16 @@ impl CanvasToolCtx {
                             return false;
                         }
                     }
-                    true
+                    return true;
                 });
                 if new_elements.len() != old_elements.len() {
                     vcanvas.update(|canvas: &mut Canvas| {
                         *canvas = Canvas::new_with_elements(new_elements);
                     });
                 }
-                ctx.set_handled();
             }
             (CanvasToolState::Erasing, Event::MouseUp(_)) => {
                 self.state = CanvasToolState::Idle;
-                ctx.set_handled();
             }
             _ => {}
         }
@@ -124,7 +125,7 @@ impl CanvasToolCtx {
 
     pub fn handle_pen_event(
         &mut self,
-        ctx: &mut EventCtx,
+        _ctx: &EventCtx,
         event: &Event,
         vcanvas: &mut VersionedCanvas,
         transform: Affine,
@@ -144,7 +145,6 @@ impl CanvasToolCtx {
                         },
                     };
                 }
-                ctx.set_handled();
             }
             (
                 CanvasToolState::DrawingFreehand {
@@ -157,7 +157,6 @@ impl CanvasToolCtx {
                     path.kurbo_path
                         .line_to((mouse_event.pos.x, mouse_event.pos.y));
                 }
-                ctx.set_handled();
             }
             (CanvasToolState::DrawingFreehand { .. }, Event::MouseUp(_)) => {
                 vcanvas.update(move |canvas: &mut Canvas| {
@@ -178,7 +177,6 @@ impl CanvasToolCtx {
                         }
                     }
                 });
-                ctx.set_handled();
             }
             _ => {}
         }

src/widget/canvas.rs

@@ -24,7 +24,8 @@ use crate::DocumentSnapshot;
 use druid::scroll_component::ScrollComponent;
 use druid::widget::prelude::*;
 use druid::widget::Viewport;
-use druid::{Affine, Color, Data, Env, Event, Selector};
+use druid::{Affine, Color, Data, Env, Event};
+use druid::{Selector};
 
 pub const SCROLL: Selector<f64> = Selector::new("scroll_canvas");
 
@@ -98,47 +99,33 @@ impl CanvasWidget {
 impl Widget<CanvasState> for CanvasWidget {
     fn event(&mut self, ctx: &mut EventCtx, event: &Event, data: &mut CanvasState, env: &Env) {
         ctx.request_focus();
-        self.scroll_component
-            .event(&mut self.viewport, ctx, event, env);
-        if !ctx.is_handled() {
-            let mut scroll_amount = 0.0;
+        let mut needs_update = false;
         match event {
             Event::Command(cmd) => {
                 if let Some(value) = cmd.get(SCROLL) {
-                        scroll_amount = *value;
+                    self.viewport.rect.y0 += value;
+                    needs_update = true;
                 }
             }
             Event::KeyDown(key_event) => {
                 if key_event.code == druid::Code::ArrowDown {
-                        scroll_amount = 30.0;
+                    self.viewport.rect.y0 += 30.0;
+                    needs_update = true;
                 } else if key_event.code == druid::Code::ArrowUp {
-                        scroll_amount = -30.0;
+                    self.viewport.rect.y0 = 0.0_f64.max(self.viewport.rect.y0 - 30.0);
+                    needs_update = true;
                 }
             }
             _ => {
-                    let transform =
-                        Affine::translate((self.viewport.rect.x0, self.viewport.rect.y0));
-                    data.tool_ctx.handle_event(
-                        ctx,
-                        event,
-                        &mut data.versioned_canvas,
-                        transform,
-                        env,
-                    );
+                let transform = Affine::translate((self.viewport.rect.x0, self.viewport.rect.y0));
+                data.tool_ctx
+                    .handle_event(ctx, event, &mut data.versioned_canvas, transform, env);
             }
         }
-            if scroll_amount != 0.0 {
-                self.viewport.rect.y0 = 0.0_f64.max(self.viewport.rect.y0 + scroll_amount);
-                self.scroll_component
-                    .reset_scrollbar_fade(|d| ctx.request_timer(d), env);
+        if needs_update {
             ctx.request_paint();
-                ctx.set_handled();
         }
     }
-        // TODO: replace this by own handling of Wheel event (must be able to extend content size)
-        self.scroll_component
-            .handle_scroll(&mut self.viewport, ctx, event, env);
-    }
 
     fn lifecycle(
         &mut self,