stiletto/src/tool.rs

//  Stiletto
//  Copyright (C) 2020 Stiletto Authors
//
//  This program is free software: you can redistribute it and/or modify
//  it under the terms of the GNU Affero General Public License as published by
//  the Free Software Foundation, either version 3 of the License, or
//  (at your option) any later version.
//
//  This program is distributed in the hope that it will be useful,
//  but WITHOUT ANY WARRANTY; without even the implied warranty of
//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
//  GNU Affero General Public License for more details.
//
//  You should have received a copy of the GNU Affero General Public License
//  along with this program.  If not, see <https://www.gnu.org/licenses/>.

use druid::kurbo::BezPath;
use druid::{Affine, Color, Data, Env, Event, EventCtx, PaintCtx};

use crate::canvas;
use crate::canvas::{Canvas, CanvasElement};
use crate::history::VersionedCanvas;

#[derive(Clone, Data)]
pub enum CanvasToolParams {
    Pen { thickness: f64, color: Color },
    Eraser,
}

#[derive(Clone, PartialEq)]
pub enum CanvasToolType {
    Pen,
    Eraser,
}

#[derive(Clone, Data)]
pub enum CanvasToolState {
    Idle,
    DrawingFreehand {
        pen_params: CanvasToolParams,
        current_path: CanvasElement,
    },
    Erasing,
}

#[derive(Clone, Data)]
pub struct CanvasToolCtx {
    initial_params: CanvasToolParams,
    state: CanvasToolState,
}

impl CanvasToolParams {
    pub fn tool_type(&self) -> CanvasToolType {
        match self {
            CanvasToolParams::Pen { .. } => CanvasToolType::Pen,
            CanvasToolParams::Eraser => CanvasToolType::Eraser,
        }
    }
}

impl CanvasToolCtx {
    pub fn new(params: CanvasToolParams) -> Self {
        CanvasToolCtx {
            initial_params: params,
            state: CanvasToolState::Idle,
        }
    }

    pub fn handle_event(
        &mut self,
        mut ctx: &mut 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),
        }
    }

    pub fn handle_erase_event(
        &mut self,
        ctx: &mut EventCtx,
        event: &Event,
        vcanvas: &mut VersionedCanvas,
        transform: Affine,
        _env: &Env,
    ) {
        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 =
                    druid::Rect::from_center_size(transform * mouse_event.pos, (5.0, 5.0));
                let old_elements = vcanvas.get().elements();
                let mut new_elements = old_elements.clone();
                new_elements.retain(|elem| {
                    // Check if the element intersects the eraser rect
                    if elem.bounding_box().intersect(eraser_rect).area() > 0.0 {
                        if elem.intersects_rect(eraser_rect) {
                            return false;
                        }
                    }
                    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();
            }
            _ => {}
        }
    }

    pub fn handle_pen_event(
        &mut self,
        ctx: &mut EventCtx,
        event: &Event,
        vcanvas: &mut VersionedCanvas,
        transform: Affine,
        _env: &Env,
    ) {
        match (&mut self.state, event) {
            (CanvasToolState::Idle, Event::MouseDown(mouse_event)) => {
                let mut kurbo_path = BezPath::new();
                kurbo_path.move_to((mouse_event.pos.x, mouse_event.pos.y));
                if let CanvasToolParams::Pen { thickness, color } = &self.initial_params {
                    self.state = CanvasToolState::DrawingFreehand {
                        pen_params: self.initial_params.clone(),
                        current_path: CanvasElement::Freehand {
                            path: canvas::Path { kurbo_path },
                            thickness: *thickness,
                            stroke_color: color.clone(),
                        },
                    };
                }
                ctx.set_handled();
            }
            (
                CanvasToolState::DrawingFreehand {
                    ref mut current_path,
                    ..
                },
                Event::MouseMove(mouse_event),
            ) => {
                if let CanvasElement::Freehand { ref mut path, .. } = current_path {
                    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| {
                    let current_state = std::mem::replace(&mut self.state, CanvasToolState::Idle);
                    if let CanvasToolState::DrawingFreehand { current_path, .. } = current_state {
                        if let CanvasElement::Freehand {
                            mut path,
                            mut thickness,
                            stroke_color,
                        } = current_path
                        {
                            path.kurbo_path.apply_affine(transform);
                            canvas.add_element(CanvasElement::Freehand {
                                path,
                                thickness,
                                stroke_color,
                            });
                        }
                    }
                });
                ctx.set_handled();
            }
            _ => {}
        }
    }

    pub fn needs_repaint(&self) -> bool {
        true
    }

    pub fn paint(&self, ctx: &mut PaintCtx, _env: &Env) {
        match &self.state {
            CanvasToolState::DrawingFreehand { current_path, .. } => current_path.draw(ctx),
            _ => {}
        }
    }
}