Struct piet::StrokeStyle

pub struct StrokeStyle {
    pub line_join: LineJoin,
    pub line_cap: LineCap,
    pub dash_pattern: StrokeDash,
    pub dash_offset: f64,
}

Options for drawing stroked lines.

You may configure particular aspects of the style by using the methods described below.

Defaults

Currently, the style (and its various consituent parts) have Default impls that conform to the defaults described in the Postscript Language Manual, 3rd Edition; that document is the basis for the choice of these types, and can be consulted for detailed explanations and illustrations.

It is possible that in the future certain of these defaults may change; if you are particular about your style you can create the various types explicitly instead of relying on the default impls.

use piet::{LineJoin, StrokeStyle};

const CONST_STLYE: StrokeStyle = StrokeStyle::new()
    .dash_pattern(&[5.0, 1.0, 2.0])
    .line_join(LineJoin::Round);

let style = StrokeStyle::new()
    .dash_pattern(&[10.0, 5.0, 2.0])
    .dash_offset(5.0);

Fields

line_join: LineJoin

How to join segments of the path.

By default, this is LineJoin::Miter with a limit of 10.0.

line_cap: LineCap

How to terminate open paths.

(closed paths do not have ends.)

by default, this is LineCap::Butt.

dash_pattern: StrokeDash

The sequence of alternating dashes and gaps uses to draw the line.

If the sequence is not empty, all numbers should be finite and non-negative, and the sequence should not be all zeros.

On platforms that do not support an odd number of lengths in the array, the implementation may concatenate two copies of the array to reach an even count.

By default, this is empty (&[]), indicating a solid line.

dash_offset: f64

The distance into the dash_pattern at which drawing begins.

By default, this is 0.0.

Implementations

impl StrokeStyle

pub const fn new() -> StrokeStyle

Create a new StrokeStyle with the provided pattern.

For no pattern (a solid line) pass &[].

This is available in a const context and does not allocate; the other methods for setting the dash pattern do allocate, for annoying reasons.

Example

 use piet::{LineJoin, StrokeStyle};

 const STYLE: StrokeStyle = StrokeStyle::new()
    .dash_pattern(&[4.0, 2.0])
    .dash_offset(8.0)
    .line_join(LineJoin::Round);

pub const fn line_join(self, line_join: LineJoin) -> Self

Builder-style method to set the LineJoin.

pub const fn line_cap(self, line_cap: LineCap) -> Self

Builder-style method to set the LineCap.

pub const fn dash_offset(self, offset: f64) -> Self

Builder-style method to set the dash_offset.

pub const fn dash_pattern(self, lengths: &'static [f64]) -> Self

Builder-style method to set the dash_pattern.

This method takes a &'static [f64], and does not allocate. If you do not have a static slice, you may use set_dash_pattern instead, which does allocate.

pub fn set_line_join(&mut self, line_join: LineJoin)

Set the LineJoin.

pub fn set_line_cap(&mut self, line_cap: LineCap)

Set the LineCap.

pub fn set_dash_offset(&mut self, offset: f64)

Set the dash offset.

pub fn set_dash_pattern(&mut self, lengths: impl Into<Rc<[f64]>>)

Set the dash pattern.

This method always allocates. To construct without allocating, use the dash_pattern builder method.

pub fn miter_limit(&self) -> Option<f64>

If the current LineJoin is LineJoin::Miter return the miter limit.

Trait Implementations

impl Clone for StrokeStyle

fn clone(&self) -> StrokeStyle

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for StrokeStyle

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

Formats the value using the given formatter.

impl Default for StrokeStyle

fn default() -> StrokeStyle

Returns the “default value” for a type.

impl PartialEq<StrokeStyle> for StrokeStyle

fn eq(&self, other: &StrokeStyle) -> bool

This method tests for self and other values to be equal, and is used by ==.

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

This method tests for !=.

impl StructuralPartialEq for StrokeStyle