Add stroke_dasharray to Style struct

[Oddball777]

I think this could be a very useful and very simple addition. I've succeeded at implementing it by:

• adding a new field in the Style struct
• adding new behaviour in the Default and Display implementations for Style
• adding a new with_stroke_dasharray function to the Svg impl.

I haven't really checked if that's all that's necessary but the feature seems pretty simple to add and it seems to work pretty well. I'll put the modified code in the comments. If this is something that you'd like implemented, I think it could also be worth considering adding more options like stroke line-cap and stroke-linejoin. If the Style struct grows too big, maybe some of the stroke parameters could be bundled together into a struct of their own. Dashes are something that's really lacking in most svg crates in Rust. I can submit a PR if you think this is a good idea.

Here's an example of what some shapes with a dashed stroke look like (generated with the modified Style struct):

use geo::{Coord, Point, Triangle};
use geo_svg::{Color, ToSvg};

let point = geo::Point::new(0.0, 0.0);
    let triangle = geo::Triangle::new(
        Coord { x: -20, y: 10 },
        Coord { x: 0, y: -10 },
        Coord { x: 20, y: 10 },
    );

    let svg_point = point
        .to_svg()
        .with_radius(40.0)
        .with_fill_opacity(0.0)
        .with_stroke_color(Color::Named("blue"))
        .with_stroke_width(1.0)
        .with_stroke_dasharray(vec![2.0, 1.0, 3.0, 1.0]); // 2 units on, 1 unit off, 3 units on, 1 unit off

    let svg_triangle = triangle
        .to_svg()
        .with_fill_opacity(0.5)
        .with_color(Color::Named("red"))
        .with_stroke_width(0.3)
        .with_stroke_dasharray(vec![1.0, 1.0]); // 1 unit on, 1 unit off

    let svg = svg_point.and(svg_triangle);

[Oddball777]

Modified style.rs:

use crate::Color;
use std::fmt::{Display, Formatter, Result};

#[derive(Debug, Clone, PartialEq)]
pub struct Style {
    pub opacity: Option<f32>,
    pub fill: Option<Color>,
    pub fill_opacity: Option<f32>,
    pub stroke_color: Option<Color>,
    pub stroke_width: Option<f32>,
    pub stroke_opacity: Option<f32>,
    pub stroke_dasharray: Option<Vec<f32>>, // New field for dash pattern
    pub radius: f32,
}

impl Default for Style {
    fn default() -> Self {
        Self {
            opacity: None,
            fill: None,
            fill_opacity: None,
            stroke_color: None,
            stroke_width: None,
            stroke_opacity: None,
            stroke_dasharray: None, // Default to None
            radius: 1.0,
        }
    }
}

impl Display for Style {
    fn fmt(&self, fmt: &mut Formatter) -> Result {
        if let Some(opacity) = self.opacity {
            write!(fmt, r#" opacity="{}""#, opacity)?;
        }
        if let Some(fill) = self.fill {
            write!(fmt, r#" fill="{}""#, fill)?;
        }
        if let Some(fill_opacity) = self.fill_opacity {
            write!(fmt, r#" fill-opacity="{}""#, fill_opacity)?;
        }
        if let Some(stroke_color) = self.stroke_color {
            write!(fmt, r#" stroke="{}""#, stroke_color)?;
        }
        if let Some(stroke_width) = self.stroke_width {
            write!(fmt, r#" stroke-width="{}""#, stroke_width)?;
        }
        if let Some(stroke_opacity) = self.stroke_opacity {
            write!(fmt, r#" stroke-opacity="{}""#, stroke_opacity)?;
        }
        if let Some(stroke_dasharray) = &self.stroke_dasharray {
            // Convert the dash array to a space-separated string
            let dasharray_str = stroke_dasharray
                .iter()
                .map(|v| v.to_string())
                .collect::<Vec<_>>()
                .join(" ");
            write!(fmt, r#" stroke-dasharray="{}""#, dasharray_str)?;
        }
        Ok(())
    }
}

New method in Svg impl:

impl<'a> Svg<'a> {

    // existing methods

    pub fn with_stroke_dasharray(mut self, dasharray: Vec<f32>) -> Self {
        self.style.stroke_dasharray = Some(dasharray.clone());
        for sibling in &mut self.siblings {
            *sibling = sibling.clone().with_stroke_dasharray(dasharray.clone());
        }
        self
    }
}

[JasmineLowen]

Hey, sorry for the late reply!

The idea sounds great. I'd be happy to review a PR of yours. Thanks for putting time into designing and implementing a feature! 💚