grafia 0.9.0

Interactive 2D cubic Bezier, spline, glyph, and vector canvas widget for egui with boolean path ops, text stream kerning, and auto-trace.
Documentation
//! Pass 4 (`nodes`), Pass 5 (`marquee`), and `ShapeThumbnail` view passes for `CanvasPainter`.

use crate::adapters::painter_pass::CanvasPainter;
use crate::adapters::state::CanvasTool;
use crate::core::NodeType;
use crate::render::{
    compute_open_contour_endpoint_ticks, compute_start_node_arrow_triangle, ProjectedNode,
    ShapeThumbnailProjection,
};
use crate::tokens::{
    CURVE_FLATTEN_TOLERANCE, GHOST_NODE_STROKE_WIDTH_DP, START_NODE_ARROW_OUTLINE_WIDTH_DP,
};
use egui::epaint::{PathShape, PathStroke};
use egui::{Pos2, Rect, Shape, Stroke, StrokeKind};

impl<'a> CanvasPainter<'a> {
    pub(crate) fn pass_4_nodes(&self) {
        let vp = self.state.active_slot_viewport();
        crate::render::paint_duplicate_warnings_egui(self.painter, self.state, self.theme);
        crate::render::paint_alignment_badges_egui(self.painter, self.state);
        let arrow_color = self.theme.start_node_arrow_color32();
        let sw = self.theme.edit_canvas.contour_stroke_width_dp;
        let open_tick_stroke = Stroke::new(sw, self.theme.open_endpoint_color32());

        for (c_idx, contour) in self.state.contours.iter().enumerate() {
            let is_closed = self.state.is_contour_closed(c_idx);
            let is_single_open_point = !is_closed
                && contour.len() == 1
                && contour[0].node_type == NodeType::Corner
                && self
                    .state
                    .pending_pen_bcp_out
                    .is_none_or(|(c, _)| c != c_idx)
                && self
                    .state
                    .pending_pen_first_bcp_in
                    .is_none_or(|(c, _)| c != c_idx);
            for node in contour {
                self.paint_single_contour_node(node, is_single_open_point, &vp);
            }

            if self.state.show_nodes_oncurve {
                if let Some([tip, left, right]) =
                    compute_start_node_arrow_triangle(contour, is_closed, &vp)
                {
                    self.painter.add(Shape::convex_polygon(
                        vec![
                            Pos2::new(tip.x.0, tip.y.0),
                            Pos2::new(left.x.0, left.y.0),
                            Pos2::new(right.x.0, right.y.0),
                        ],
                        arrow_color,
                        Stroke::new(
                            START_NODE_ARROW_OUTLINE_WIDTH_DP,
                            self.theme.canvas_background_color32(),
                        ),
                    ));
                }
            }

            if !is_closed {
                for (pa, pb) in compute_open_contour_endpoint_ticks(contour, &vp) {
                    self.painter.line_segment(
                        [Pos2::new(pa.x.0, pa.y.0), Pos2::new(pb.x.0, pb.y.0)],
                        open_tick_stroke,
                    );
                }
            }
        }

        if self.state.active_tool == CanvasTool::Pen {
            if let Some(hit) = self.state.hovered_segment_hit {
                let ghost_scr = vp.to_screen(hit.point);
                let ghost_pos = Pos2::new(ghost_scr.x.0, ghost_scr.y.0);
                let half = self.theme.edit_canvas.node_size_dp * 0.5;
                self.painter.circle_stroke(
                    ghost_pos,
                    half,
                    Stroke::new(
                        GHOST_NODE_STROKE_WIDTH_DP,
                        self.theme.edit_canvas.selected_glow_color32(),
                    ),
                );
                self.painter.circle_filled(
                    ghost_pos,
                    half * 0.5,
                    self.theme.edit_canvas.smooth_node_color32(),
                );
            }
        }
    }

    fn paint_single_contour_node(
        &self,
        node: &crate::core::Node,
        is_single_open_point: bool,
        vp: &crate::core::ViewportTransform,
    ) {
        if (node.node_type == NodeType::OffCurve && !self.state.show_nodes_offcurve)
            || (node.node_type != NodeType::OffCurve && !self.state.show_nodes_oncurve)
        {
            return;
        }
        let corner_color = self.theme.edit_canvas.corner_node_color32();
        let smooth_color = self.theme.edit_canvas.smooth_node_color32();
        let sw = self.theme.edit_canvas.contour_stroke_width_dp;
        let is_sel = self.state.selected_nodes.contains(&node.id);
        let proj = ProjectedNode::new(
            node.point,
            node.node_type,
            is_sel,
            vp,
            &self.theme.edit_canvas,
        );
        let center = Pos2::new(proj.screen_pos.x.0, proj.screen_pos.y.0);
        let half = self.theme.edit_canvas.node_size_dp * 0.5;
        let node_rect = Rect::from_min_max(
            Pos2::new(center.x - half, center.y - half),
            Pos2::new(center.x + half, center.y + half),
        );

        if is_single_open_point {
            let single_stroke = Stroke::new(sw, corner_color);
            self.painter.line_segment(
                [node_rect.left_top(), node_rect.right_bottom()],
                single_stroke,
            );
            self.painter.line_segment(
                [node_rect.left_bottom(), node_rect.right_top()],
                single_stroke,
            );
        } else {
            match node.node_type {
                NodeType::Corner => {
                    self.painter.rect_filled(node_rect, 0.0, corner_color);
                }
                NodeType::Smooth => {
                    self.painter.circle_filled(center, half, smooth_color);
                }
                NodeType::OffCurve => {
                    let r = self.theme.edit_canvas.bcp_handle_size_dp * 0.5;
                    crate::render::paint_offcurve_handle_egui(
                        self.painter,
                        center,
                        r,
                        self.theme.edit_canvas.handle_shape,
                        self.theme.edit_canvas.bcp_handle_color32(),
                    );
                }
                NodeType::HobbyStar { .. } | NodeType::EulerSpiro { .. } => {
                    crate::render::paint_spline_node_marker_egui(
                        self.painter,
                        center,
                        node.node_type,
                        self.theme,
                    );
                }
            }
        }
        if is_sel {
            let glow_rect = Rect::from_min_max(
                Pos2::new(node_rect.left() - sw, node_rect.top() - sw),
                Pos2::new(node_rect.right() + sw, node_rect.bottom() + sw),
            );
            let glow_stroke = Stroke::new(sw * 2.0, self.theme.edit_canvas.selected_glow_color32());
            self.painter
                .rect_stroke(glow_rect, 0.0, glow_stroke, StrokeKind::Middle);
        }
    }

    pub(crate) fn pass_5_marquee(&self) {
        if let crate::interaction::SelectToolState::MarqueeSelecting {
            start_screen,
            current_screen,
        } = self.state.select_state
        {
            if self.state.show_bounding_box_slanted && self.state.selection_angle_deg.abs() > 0.0 {
                let verts = crate::core::slanted_marquee_parallelogram_screen(
                    start_screen,
                    current_screen,
                    self.state.selection_angle_deg,
                );
                let points: Vec<Pos2> = verts.iter().map(|p| Pos2::new(p.x.0, p.y.0)).collect();
                self.painter.add(Shape::Path(PathShape {
                    points,
                    closed: true,
                    fill: self.theme.edit_canvas.rubberband_fill_color32(),
                    stroke: PathStroke::new(
                        self.theme.edit_canvas.rubberband_stroke_width_dp,
                        self.theme.edit_canvas.rubberband_stroke_color32(),
                    ),
                }));
                return;
            }
        }
        if let Some(rect) = self.state.select_state.marquee_rect() {
            let egui_rect = Rect::from_min_max(
                Pos2::new(rect.x0 as f32, rect.y0 as f32),
                Pos2::new(rect.x1 as f32, rect.y1 as f32),
            );
            self.painter.rect_filled(
                egui_rect,
                0.0,
                self.theme.edit_canvas.rubberband_fill_color32(),
            );
            self.painter.rect_stroke(
                egui_rect,
                0.0,
                Stroke::new(
                    self.theme.edit_canvas.rubberband_stroke_width_dp,
                    self.theme.edit_canvas.rubberband_stroke_color32(),
                ),
                StrokeKind::Middle,
            );
        }
    }

    pub(crate) fn paint_shape_thumbnails(&self) {
        let scale = crate::core::math_consts::SHAPE_THUMBNAIL_CARD_SCALE;
        let pad = self.theme.shape_canvas.header_height_dp * 2.0;
        let mut row_y = self.canvas_rect.top() + pad + self.theme.shape_canvas.header_height_dp;
        let card_w = self.theme.shape_canvas.thumbnail_width_dp * scale;
        let card_h = self.theme.shape_canvas.thumbnail_height_dp * scale;

        for (idx, path) in self.state.paths.iter().enumerate() {
            let is_closed = self.state.is_contour_closed(idx);
            let node_count = self.state.contours.get(idx).map_or(0, |c| c.len());
            let mut scaled_cfg = self.theme.shape_canvas.clone();
            scaled_cfg.thumbnail_width_dp = card_w;
            scaled_cfg.thumbnail_height_dp = card_h;
            scaled_cfg.thumbnail_padding_dp = self.theme.shape_canvas.thumbnail_padding_dp * scale;
            let proj = ShapeThumbnailProjection::compute(path, &scaled_cfg, node_count, true);
            let card_rect = Rect::from_min_size(
                Pos2::new(self.canvas_rect.left() + pad, row_y),
                egui::Vec2::new(card_w, card_h),
            );
            self.painter.rect_filled(
                card_rect,
                self.theme.shape_canvas.selection_corner_radius_dp,
                self.theme.shape_canvas.accent_selection_color32(),
            );
            let mut points = Vec::new();
            kurbo::flatten(
                proj.fitted_path.iter(),
                CURVE_FLATTEN_TOLERANCE,
                |el| match el {
                    kurbo::PathEl::MoveTo(p) | kurbo::PathEl::LineTo(p) => {
                        points.push(Pos2::new(
                            card_rect.min.x + p.x as f32,
                            card_rect.min.y + p.y as f32,
                        ));
                    }
                    _ => {}
                },
            );
            if points.len() >= 2 {
                let active_color = self.theme.shape_canvas.text_active_color32();
                if is_closed {
                    let mesh = crate::render::tessellate_bez_path_nonzero(
                        &proj.fitted_path,
                        card_rect.min,
                        active_color,
                    );
                    if !mesh.is_empty() {
                        self.painter.add(Shape::mesh(mesh));
                    }
                }
                let path_fill = if is_closed && crate::render::is_polygon_convex(&points) {
                    active_color
                } else {
                    egui::Color32::TRANSPARENT
                };
                self.painter.add(Shape::Path(PathShape {
                    points,
                    closed: is_closed,
                    fill: path_fill,
                    stroke: PathStroke::new(
                        self.theme.edit_canvas.contour_stroke_width_dp,
                        active_color,
                    ),
                }));
            }
            row_y += card_h + self.theme.shape_canvas.header_height_dp;
        }
    }
}