Add support for more complex strokes (typst#505)

Author: birktj

library/src/math/frac.rs

@@ -135,6 +135,7 @@ fn layout(
                 Geometry::Line(Point::with_x(line_width)).stroked(Stroke {
                     paint: TextElem::fill_in(ctx.styles()),
                     thickness,
+                    ..Stroke::default()
                 }),
                 span,
             ),

library/src/math/root.rs

@@ -121,8 +121,11 @@ fn layout(
     frame.push(
         line_pos,
         FrameItem::Shape(
-            Geometry::Line(Point::with_x(radicand.width()))
-                .stroked(Stroke { paint: TextElem::fill_in(ctx.styles()), thickness }),
+            Geometry::Line(Point::with_x(radicand.width())).stroked(Stroke {
+                paint: TextElem::fill_in(ctx.styles()),
+                thickness,
+                ..Stroke::default()
+            }),
             span,
         ),
     );

library/src/text/deco.rs

@@ -271,6 +271,7 @@ pub(super) fn decorate(
     let stroke = deco.stroke.clone().unwrap_or(Stroke {
         paint: text.fill.clone(),
         thickness: metrics.thickness.at(text.size),
+        ..Stroke::default()
     });
 
     let gap_padding = 0.08 * text.size;

library/src/visualize/line.rs

@@ -40,9 +40,32 @@ pub struct LineElem {
     ///   to `{1pt}`.
     /// - A stroke combined from color and thickness using the `+` operator as
     ///   in `{2pt + red}`.
+    /// - A stroke described by a dictionary with any of the following keys:
+    ///     - `color`: the color to use for the stroke
+    ///     - `thickness`: the stroke's thickness
+    ///     - `cap`: one of `"butt"`, `"round"` or `"square"`, the line cap of the stroke
+    ///     - `join`: one of `"miter"`, `"round"` or `"bevel"`, the line join of the stroke
+    ///     - `miter-limit`: the miter limit to use if `join` is `"miter"`, defaults to 4.0
+    ///     - `dash`: the dash pattern to use. Can be any of the following:
+    ///         - One of the strings `"solid"`, `"dotted"`, `"densely-dotted"`, `"loosely-dotted"`,
+    ///           `"dashed"`, `"densely-dashed"`, `"loosely-dashed"`, `"dashdotted"`,
+    ///           `"densely-dashdotted"` or `"loosely-dashdotted"`
+    ///         - An array with elements that specify the lengths of dashes and gaps, alternating.
+    ///           Elements can also be the string `"dot"` for a length equal to the line thickness.
+    ///         - A dict with the keys `array`, same as the array above, and `phase`, the offset to
+    ///           the start of the first dash.
+    ///     
     ///
     /// ```example
-    /// #line(length: 100%, stroke: 2pt + red)
+    /// #stack(
+    ///   line(length: 100%, stroke: 2pt + red),
+    ///   v(1em),
+    ///   line(length: 100%, stroke: (color: blue, thickness: 4pt, cap: "round")),
+    ///   v(1em),
+    ///   line(length: 100%, stroke: (color: blue, thickness: 1pt, dash: "dashed")),
+    ///   v(1em),
+    ///   line(length: 100%, stroke: (color: blue, thickness: 1pt, dash: ("dot", 2pt, 4pt, 2pt))),
+    /// )
     /// ```
     #[resolve]
     #[fold]

library/src/visualize/shape.rs

@@ -47,8 +47,22 @@ pub struct RectElem {
     ///   to `{1pt}`.
     /// - A stroke combined from color and thickness using the `+` operator as
     ///   in `{2pt + red}`.
-    /// - A dictionary: With a dictionary, the stroke for each side can be set
-    ///   individually. The dictionary can contain the following keys in order
+    /// - A stroke described by a dictionary with any of the following keys:
+    ///     - `color`: the color to use for the stroke
+    ///     - `thickness`: the stroke's thickness
+    ///     - `cap`: one of `"butt"`, `"round"` or `"square"`, the line cap of the stroke
+    ///     - `join`: one of `"miter"`, `"round"` or `"bevel"`, the line join of the stroke
+    ///     - `miter-limit`: the miter limit to use if `join` is `"miter"`, defaults to 4.0
+    ///     - `dash`: the dash pattern to use. Can be any of the following:
+    ///         - One of the strings `"solid"`, `"dotted"`, `"densely-dotted"`, `"loosely-dotted"`,
+    ///           `"dashed"`, `"densely-dashed"`, `"loosely-dashed"`, `"dashdotted"`,
+    ///           `"densely-dashdotted"` or `"loosely-dashdotted"`
+    ///         - An array with elements that specify the lengths of dashes and gaps, alternating.
+    ///           Elements can also be the string `"dot"` for a length equal to the line thickness.
+    ///         - A dict with the keys `array`, same as the array above, and `phase`, the offset to
+    ///           the start of the first dash.
+    /// - Another dictionary describing the stroke for each side inidvidually.
+    ///   The dictionary can contain the following keys in order
     ///   of precedence:
     ///   - `top`: The top stroke.
     ///   - `right`: The right stroke.

src/doc.rs

@@ -359,6 +359,7 @@ impl Frame {
                 Geometry::Line(Point::with_x(self.size.x)).stroked(Stroke {
                     paint: Color::RED.into(),
                     thickness: Abs::pt(1.0),
+                    ..Stroke::default()
                 }),
                 Span::detached(),
             ),
@@ -386,6 +387,7 @@ impl Frame {
                 Geometry::Line(Point::with_x(self.size.x)).stroked(Stroke {
                     paint: Color::GREEN.into(),
                     thickness: Abs::pt(1.0),
+                    ..Stroke::default()
                 }),
                 Span::detached(),
             ),

src/eval/ops.rs

@@ -108,6 +108,7 @@ pub fn add(lhs: Value, rhs: Value) -> StrResult<Value> {
             Value::dynamic(PartialStroke {
                 paint: Smart::Custom(color.into()),
                 thickness: Smart::Custom(thickness),
+                ..PartialStroke::default()
             })
         }
 

src/export/pdf/page.rs

@@ -1,14 +1,16 @@
 use ecow::eco_format;
-use pdf_writer::types::{ActionType, AnnotationType, ColorSpaceOperand};
+use pdf_writer::types::{
+    ActionType, AnnotationType, ColorSpaceOperand, LineCapStyle, LineJoinStyle,
+};
 use pdf_writer::writers::ColorSpace;
 use pdf_writer::{Content, Filter, Finish, Name, Rect, Ref, Str};
 
 use super::{deflate, AbsExt, EmExt, PdfContext, RefExt, D65_GRAY, SRGB};
 use crate::doc::{Destination, Frame, FrameItem, GroupItem, Meta, TextItem};
 use crate::font::Font;
 use crate::geom::{
-    self, Abs, Color, Em, Geometry, Numeric, Paint, Point, Ratio, Shape, Size, Stroke,
-    Transform,
+    self, Abs, Color, Em, Geometry, LineCap, LineJoin, Numeric, Paint, Point, Ratio,
+    Shape, Size, Stroke, Transform,
 };
 use crate::image::Image;
 
@@ -250,8 +252,17 @@ impl PageContext<'_, '_> {
 
     fn set_stroke(&mut self, stroke: &Stroke) {
         if self.state.stroke.as_ref() != Some(stroke) {
+            let Stroke {
+                paint,
+                thickness,
+                line_cap,
+                line_join,
+                dash_pattern,
+                miter_limit,
+            } = stroke;
+
             let f = |c| c as f32 / 255.0;
-            let Paint::Solid(color) = stroke.paint;
+            let Paint::Solid(color) = paint;
             match color {
                 Color::Luma(c) => {
                     self.set_stroke_color_space(D65_GRAY);
@@ -267,7 +278,26 @@ impl PageContext<'_, '_> {
                 }
             }
 
-            self.content.set_line_width(stroke.thickness.to_f32());
+            self.content.set_line_width(thickness.to_f32());
+            if self.state.stroke.as_ref().map(|s| &s.line_cap) != Some(line_cap) {
+                self.content.set_line_cap(line_cap.into());
+            }
+            if self.state.stroke.as_ref().map(|s| &s.line_join) != Some(line_join) {
+                self.content.set_line_join(line_join.into());
+            }
+            if self.state.stroke.as_ref().map(|s| &s.dash_pattern) != Some(dash_pattern) {
+                if let Some(pattern) = dash_pattern {
+                    self.content.set_dash_pattern(
+                        pattern.array.iter().map(|l| l.to_f32()),
+                        pattern.phase.to_f32(),
+                    );
+                } else {
+                    self.content.set_dash_pattern([], 0.0);
+                }
+            }
+            if self.state.stroke.as_ref().map(|s| &s.miter_limit) != Some(miter_limit) {
+                self.content.set_miter_limit(miter_limit.0 as f32);
+            }
             self.state.stroke = Some(stroke.clone());
         }
     }
@@ -486,3 +516,23 @@ fn write_link(ctx: &mut PageContext, pos: Point, dest: &Destination, size: Size)
 
     ctx.links.push((dest.clone(), rect));
 }
+
+impl From<&LineCap> for LineCapStyle {
+    fn from(line_cap: &LineCap) -> Self {
+        match line_cap {
+            LineCap::Butt => LineCapStyle::ButtCap,
+            LineCap::Round => LineCapStyle::RoundCap,
+            LineCap::Square => LineCapStyle::ProjectingSquareCap,
+        }
+    }
+}
+
+impl From<&LineJoin> for LineJoinStyle {
+    fn from(line_join: &LineJoin) -> Self {
+        match line_join {
+            LineJoin::Miter => LineJoinStyle::MiterJoin,
+            LineJoin::Round => LineJoinStyle::RoundJoin,
+            LineJoin::Bevel => LineJoinStyle::BevelJoin,
+        }
+    }
+}

src/export/render.rs

@@ -11,7 +11,8 @@ use usvg::{FitTo, NodeExt};
 
 use crate::doc::{Frame, FrameItem, GroupItem, Meta, TextItem};
 use crate::geom::{
-    self, Abs, Color, Geometry, Paint, PathItem, Shape, Size, Stroke, Transform,
+    self, Abs, Color, Geometry, LineCap, LineJoin, Paint, PathItem, Shape, Size, Stroke,
+    Transform,
 };
 use crate::image::{DecodedImage, Image};
 
@@ -392,9 +393,36 @@ fn render_shape(
         canvas.fill_path(&path, &paint, rule, ts, mask);
     }
 
-    if let Some(Stroke { paint, thickness }) = &shape.stroke {
+    if let Some(Stroke {
+        paint,
+        thickness,
+        line_cap,
+        line_join,
+        dash_pattern,
+        miter_limit,
+    }) = &shape.stroke
+    {
+        let dash = dash_pattern.as_ref().and_then(|pattern| {
+            // tiny-skia only allows dash patterns with an even number of elements,
+            // while pdf allows any number.
+            let len = if pattern.array.len() % 2 == 1 {
+                pattern.array.len() * 2
+            } else {
+                pattern.array.len()
+            };
+            let dash_array =
+                pattern.array.iter().map(|l| l.to_f32()).cycle().take(len).collect();
+
+            sk::StrokeDash::new(dash_array, pattern.phase.to_f32())
+        });
         let paint = paint.into();
-        let stroke = sk::Stroke { width: thickness.to_f32(), ..Default::default() };
+        let stroke = sk::Stroke {
+            width: thickness.to_f32(),
+            line_cap: line_cap.into(),
+            line_join: line_join.into(),
+            dash,
+            miter_limit: miter_limit.0 as f32,
+        };
         canvas.stroke_path(&path, &paint, &stroke, ts, mask);
     }
 
@@ -525,6 +553,26 @@ impl From<Color> for sk::Color {
     }
 }
 
+impl From<&LineCap> for sk::LineCap {
+    fn from(line_cap: &LineCap) -> Self {
+        match line_cap {
+            LineCap::Butt => sk::LineCap::Butt,
+            LineCap::Round => sk::LineCap::Round,
+            LineCap::Square => sk::LineCap::Square,
+        }
+    }
+}
+
+impl From<&LineJoin> for sk::LineJoin {
+    fn from(line_join: &LineJoin) -> Self {
+        match line_join {
+            LineJoin::Miter => sk::LineJoin::Miter,
+            LineJoin::Round => sk::LineJoin::Round,
+            LineJoin::Bevel => sk::LineJoin::Bevel,
+        }
+    }
+}
+
 /// Allows to build tiny-skia paths from glyph outlines.
 struct WrappedPathBuilder(sk::PathBuilder);
 

src/geom/sides.rs

@@ -188,22 +188,30 @@ where
 
     fn cast(mut value: Value) -> StrResult<Self> {
         if let Value::Dict(dict) = &mut value {
-            let mut take = |key| dict.take(key).ok().map(T::cast).transpose();
-
-            let rest = take("rest")?;
-            let x = take("x")?.or_else(|| rest.clone());
-            let y = take("y")?.or_else(|| rest.clone());
-            let sides = Sides {
-                left: take("left")?.or_else(|| x.clone()),
-                top: take("top")?.or_else(|| y.clone()),
-                right: take("right")?.or_else(|| x.clone()),
-                bottom: take("bottom")?.or_else(|| y.clone()),
+            let mut try_cast = || -> StrResult<_> {
+                let mut take = |key| dict.take(key).ok().map(T::cast).transpose();
+
+                let rest = take("rest")?;
+                let x = take("x")?.or_else(|| rest.clone());
+                let y = take("y")?.or_else(|| rest.clone());
+                let sides = Sides {
+                    left: take("left")?.or_else(|| x.clone()),
+                    top: take("top")?.or_else(|| y.clone()),
+                    right: take("right")?.or_else(|| x.clone()),
+                    bottom: take("bottom")?.or_else(|| y.clone()),
+                };
+
+                dict.finish(&["left", "top", "right", "bottom", "x", "y", "rest"])?;
+
+                Ok(sides)
             };
 
-            dict.finish(&["left", "top", "right", "bottom", "x", "y", "rest"])?;
+            if let Ok(res) = try_cast() {
+                return Ok(res);
+            }
+        }
 
-            Ok(sides)
-        } else if T::is(&value) {
+        if T::is(&value) {
             Ok(Self::splat(Some(T::cast(value)?)))
         } else {
             <Self as Cast>::error(value)