Struct Stroke

pub struct Stroke<T = Length>
where
    T: Numeric,
{
    pub paint: Smart<Paint>,
    pub thickness: Smart<T>,
    pub cap: Smart<LineCap>,
    pub join: Smart<LineJoin>,
    pub dash: Smart<Option<DashPattern<T>>>,
    pub miter_limit: Smart<Scalar>,
}

Defines how to draw a line.

A stroke has a paint (a solid color or gradient), a thickness, a line cap, a line join, a miter limit, and a dash pattern. All of these values are optional and have sensible defaults.

Example

#set line(length: 100%)
#stack(
  spacing: 1em,
  line(stroke: 2pt + red),
  line(stroke: (paint: blue, thickness: 4pt, cap: "round")),
  line(stroke: (paint: blue, thickness: 1pt, dash: "dashed")),
  line(stroke: 2pt + gradient.linear(..color.map.rainbow)),
)

Simple strokes

You can create a simple solid stroke from a color, a thickness, or a combination of the two. Specifically, wherever a stroke is expected you can pass any of the following values:

• A length specifying the stroke’s thickness. The color is inherited, defaulting to black.
• A color to use for the stroke. The thickness is inherited, defaulting to {1pt}.
• A stroke combined from color and thickness using the + operator as in {2pt + red}.

For full control, you can also provide a [dictionary] or a {stroke} object to any function that expects a stroke. The dictionary’s keys may include any of the parameters for the constructor function, shown below.

Fields

On a stroke object, you can access any of the fields listed in the constructor function. For example, {(2pt + blue).thickness} is {2pt}. Meanwhile, {stroke(red).cap} is {auto} because it’s unspecified. Fields set to {auto} are inherited.

Fields

paint: Smart<Paint>

The stroke’s paint.

thickness: Smart<T>

The stroke’s thickness.

cap: Smart<LineCap>

The stroke’s line cap.

join: Smart<LineJoin>

The stroke’s line join.

dash: Smart<Option<DashPattern<T>>>

The stroke’s line dash pattern.

miter_limit: Smart<Scalar>

The miter limit.

Implementations

impl Stroke

pub fn from_pair(paint: impl Into<Paint>, thickness: Length) -> Stroke

Create a stroke from a paint and a thickness.

impl Stroke

pub fn construct(args: &mut Args) -> Result<Stroke, EcoVec<SourceDiagnostic>>

Converts a value to a stroke or constructs a stroke with the given parameters.

Note that in most cases you do not need to convert values to strokes in order to use them, as they will be converted automatically. However, this constructor can be useful to ensure a value has all the fields of a stroke.

#let my-func(x) = {
    x = stroke(x) // Convert to a stroke
    [Stroke has thickness #x.thickness.]
}
#my-func(3pt) \
#my-func(red) \
#my-func(stroke(cap: "round", thickness: 1pt))

impl<T> Stroke<T>

where T: Numeric,

pub fn map<F, U>(self, f: F) -> Stroke<U>

where U: Numeric, F: Fn(T) -> U,

Map the contained lengths with f.

impl Stroke<Abs>

pub fn unwrap_or(self, default: FixedStroke) -> FixedStroke

Unpack the stroke, filling missing fields from the default.

pub fn unwrap_or_default(self) -> FixedStroke

Unpack the stroke, filling missing fields with the default values.

Trait Implementations

impl<T> Clone for Stroke<T>

where T: Clone + Numeric,

fn clone(&self) -> Stroke<T>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<T> Debug for Stroke<T>

where T: Debug + Numeric,

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl<T> Default for Stroke<T>

where T: Default + Numeric,

fn default() -> Stroke<T>

Returns the “default value” for a type.

impl<T> Fold for Stroke<T>

where T: Numeric + Fold,

fn fold(self, outer: Stroke<T>) -> Stroke<T>

Fold this inner value with an outer folded value.

impl FromValue for Stroke

fn from_value(value: Value) -> Result<Stroke, HintedString>

Try to cast the value into an instance of Self.

impl<T> Hash for Stroke<T>

where T: Hash + Numeric,

fn hash<__H>(&self, state: &mut __H)

where __H: Hasher,

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl IntoValue for Stroke

fn into_value(self) -> Value

Cast this type into a value.

impl IntoValue for Stroke<Abs>

fn into_value(self) -> Value

Cast this type into a value.

impl NativeScope for Stroke

fn constructor() -> Option<&'static NativeFuncData>

The constructor function for the type, if any.

fn scope() -> Scope

Get the associated scope for the type.

impl NativeType for Stroke

const NAME: &'static str = "stroke"

The type’s name.

fn data() -> &'static NativeTypeData

fn ty() -> Type

Get the type for the native Rust type.

impl<T> PartialEq for Stroke<T>

where T: PartialEq + Numeric,

fn eq(&self, other: &Stroke<T>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Reflect for Stroke

fn input() -> CastInfo

Describe what can be cast into this value.

fn output() -> CastInfo

Describe what this value can be cast into.

fn castable(value: &Value) -> bool

Whether the given value can be converted to T.

fn error(found: &Value) -> HintedString

Produce an error message for an unacceptable value type.

impl<T> Repr for Stroke<T>

where T: Numeric + Repr,

fn repr(&self) -> EcoString

Return the debug representation of the value.

impl Resolve for Stroke

type Output = Stroke<Abs>

The type of the resolved output.

fn resolve(self, styles: StyleChain<'_>) -> <Stroke as Resolve>::Output

Resolve the value using the style chain.

impl<T> Eq for Stroke<T>

where T: Eq + Numeric,

impl<T> StructuralPartialEq for Stroke<T>

where T: Numeric,