Struct PathElem

pub struct PathElem {
    pub vertices: Vec<PathVertex>,
    /* private fields */
}

A path through a list of points, connected by Bézier curves.

Example

#path(
  fill: blue.lighten(80%),
  stroke: blue,
  closed: true,
  (0pt, 50pt),
  (100%, 50pt),
  ((50%, 0pt), (40pt, 0pt)),
)

Fields

vertices: Vec<PathVertex>

Implementations

impl PathElem

pub fn new(vertices: Vec<PathVertex>) -> Self

Create a new instance of the element.

pub fn with_fill(self, fill: Option<Paint>) -> Self

Builder-style setter for the fill field.

pub fn with_fill_rule(self, fill_rule: FillRule) -> Self

Builder-style setter for the fill-rule field.

pub fn with_stroke(self, stroke: Smart<Option<Stroke>>) -> Self

Builder-style setter for the stroke field.

pub fn with_closed(self, closed: bool) -> Self

Builder-style setter for the closed field.

pub fn push_fill(&mut self, fill: Option<Paint>)

Setter for the fill field.

pub fn push_fill_rule(&mut self, fill_rule: FillRule)

Setter for the fill-rule field.

pub fn push_stroke(&mut self, stroke: Smart<Option<Stroke>>)

Setter for the stroke field.

pub fn push_closed(&mut self, closed: bool)

Setter for the closed field.

pub fn fill(&self, styles: StyleChain<'_>) -> Option<Paint>

How to fill the path.

When setting a fill, the default stroke disappears. To create a rectangle with both fill and stroke, you have to configure both.

pub fn fill_rule(&self, styles: StyleChain<'_>) -> FillRule

The drawing rule used to fill the path.

// We use `.with` to get a new
// function that has the common
// arguments pre-applied.
#let star = path.with(
  fill: red,
  closed: true,
  (25pt, 0pt),
  (10pt, 50pt),
  (50pt, 20pt),
  (0pt, 20pt),
  (40pt, 50pt),
)

#star(fill-rule: "non-zero")
#star(fill-rule: "even-odd")

pub fn stroke( &self, styles: StyleChain<'_>, ) -> <Smart<Option<Stroke>> as Resolve>::Output

How to [stroke] the path. This can be:

Can be set to {none} to disable the stroke or to {auto} for a stroke of {1pt} black if and if only if no fill is given.

pub fn closed(&self, styles: StyleChain<'_>) -> bool

Whether to close this path with one last Bézier curve. This curve will take into account the adjacent control points. If you want to close with a straight line, simply add one last point that’s the same as the start point.

pub fn fill_in(styles: StyleChain<'_>) -> Option<Paint>

Access the fill field in the given style chain.

pub fn fill_rule_in(styles: StyleChain<'_>) -> FillRule

Access the fill-rule field in the given style chain.

pub fn stroke_in( styles: StyleChain<'_>, ) -> <Smart<Option<Stroke>> as Resolve>::Output

Access the stroke field in the given style chain.

pub fn closed_in(styles: StyleChain<'_>) -> bool

Access the closed field in the given style chain.

pub fn set_fill(fill: Option<Paint>) -> Property

Create a style property for the fill field.

pub fn set_fill_rule(fill_rule: FillRule) -> Property

Create a style property for the fill-rule field.

pub fn set_stroke(stroke: Smart<Option<Stroke>>) -> Property

Create a style property for the stroke field.

pub fn set_closed(closed: bool) -> Property

Create a style property for the closed field.

Trait Implementations

impl Capable for PathElem

fn vtable(capability: TypeId) -> Option<NonNull<()>>

Get the pointer to the vtable for the given capability / trait.

impl Clone for PathElem

fn clone(&self) -> PathElem

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Construct for PathElem

fn construct(engine: &mut Engine<'_>, args: &mut Args) -> SourceResult<Content>

Construct an element from the arguments.

impl Debug for PathElem

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

Formats the value using the given formatter.

impl Fields for PathElem

type Enum = Fields

An enum with the fields of the element.

fn has(&self, id: u8) -> bool

Whether the element has the given field set.

fn field(&self, id: u8) -> Result<Value, FieldAccessError>

Get the field with the given field ID.

fn field_with_styles( &self, id: u8, styles: StyleChain<'_>, ) -> Result<Value, FieldAccessError>

Get the field with the given ID in the presence of styles.

fn field_from_styles( id: u8, styles: StyleChain<'_>, ) -> Result<Value, FieldAccessError>

Get the field with the given ID from the styles.

fn materialize(&mut self, styles: StyleChain<'_>)

Resolve all fields with the styles and save them in-place.

fn fields(&self) -> Dict

Get the fields of the element.

impl Hash for PathElem

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

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 PathElem

fn into_value(self) -> Value

Cast this type into a value.

impl NativeElement for PathElem

fn data() -> &'static NativeElementData

Get the element data for the native Rust element.

fn elem() -> Element

where Self: Sized,

Get the element for the native Rust element.

fn pack(self) -> Content

where Self: Sized,

Pack the element into type-erased content.

impl PartialEq for PathElem

fn eq(&self, other: &Self) -> 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 Repr for PathElem

fn repr(&self) -> EcoString

Return the debug representation of the value.

impl Set for PathElem

fn set(engine: &mut Engine<'_>, args: &mut Args) -> SourceResult<Styles>

Parse relevant arguments into style properties for this element.