Function draw_styled_line_segment

src/plot_renderer/canvas.rs:463–523

(
    frame: &mut Frame,
    p0: iced::Point,
    p1: iced::Point,
    line_type: LineType,
    width: f32,
    color: Color,
    phase_start: f32,
)

}

fn draw_styled_line_segment(
    frame: &mut Frame,
    p0: iced::Point,
    p1: iced::Point,
    line_type: LineType,
    width: f32,
    color: Color,
    phase_start: f32,
) {
    let delta = iced::Vector::new(p1.x - p0.x, p1.y - p0.y);
    let length = (delta.x * delta.x + delta.y * delta.y).sqrt();
    if length <= f32::EPSILON {
        return;
    }

    let direction = iced::Vector::new(delta.x / length, delta.y / length);

    match line_type {
        LineType::Solid => stroke_segment(frame, p0, p1, width, color),
        LineType::Dashed { length: dash } => {
            let dash = dash.max(1.0);
            let gap = (dash * 0.5).max(1.0);
            let pattern = dash + gap;
            let mut pattern_start = -(phase_start.rem_euclid(pattern));
            while pattern_start < length {
                let seg_start = pattern_start.max(0.0);
                let seg_end = (pattern_start + dash).min(length);
                if seg_end > seg_start {
                    let start = iced::Point::new(
                        p0.x + direction.x * seg_start,
                        p0.y + direction.y * seg_start,
                    );
                    let end = iced::Point::new(
                        p0.x + direction.x * seg_end,
                        p0.y + direction.y * seg_end,
                    );
                    stroke_segment(frame, start, end, width, color);
                }
                pattern_start += pattern;
            }
        }
        LineType::Dotted { spacing } => {
            let spacing = spacing.max(1.0);
            let step = spacing * 2.0;
            let radius = width.max(1.5) * 0.5;
            let remainder = phase_start.rem_euclid(step);
            let mut offset = if remainder <= f32::EPSILON {
                0.0
            } else {
                step - remainder
            };
            while offset <= length {
                let center =
                    iced::Point::new(p0.x + direction.x * offset, p0.y + direction.y * offset);
                let dot = canvas::Path::circle(center, radius);
                frame.fill(&dot, color);
                offset += step;
            }