Struct CurveElem

pub struct CurveElem {
    pub components: Vec<CurveComponent>,
    /* private fields */
}

A curve consisting of movements, lines, and Beziér segments.

At any point in time, there is a conceptual pen or cursor.

• Move elements move the cursor without drawing.
• Line/Quadratic/Cubic elements draw a segment from the cursor to a new position, potentially with control point for a Beziér curve.
• Close elements draw a straight or smooth line back to the start of the curve or the latest preceding move segment.

For layout purposes, the bounding box of the curve is a tight rectangle containing all segments as well as the point {(0pt, 0pt)}.

Positions may be specified absolutely (i.e. relatively to {(0pt, 0pt)}), or relative to the current pen/cursor position, that is, the position where the previous segment ended.

Beziér curve control points can be skipped by passing {none} or automatically mirrored from the preceding segment by passing {auto}.

Example

#curve(
  fill: blue.lighten(80%),
  stroke: blue,
  curve.move((0pt, 50pt)),
  curve.line((100pt, 50pt)),
  curve.cubic(none, (90pt, 0pt), (50pt, 0pt)),
  curve.close(),
)

Fields

components: Vec<CurveComponent>

Implementations

impl CurveElem

pub fn new(components: Vec<CurveComponent>) -> 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 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 fill(&self, styles: StyleChain<'_>) -> Option<Paint>

How to fill the curve.

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 curve.

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

#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 curve. 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.

#let down = curve.line((40pt, 40pt), relative: true)
#let up = curve.line((40pt, -40pt), relative: true)

#curve(
  stroke: 4pt + gradient.linear(red, blue),
  down, up, down, up, down,
)

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 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.

Trait Implementations

impl Capable for CurveElem

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

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

impl Clone for CurveElem

fn clone(&self) -> CurveElem

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Construct for CurveElem

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

Construct an element from the arguments.

impl Debug for CurveElem

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

Formats the value using the given formatter.

impl Fields for CurveElem

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 CurveElem

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 CurveElem

fn into_value(self) -> Value

Cast this type into a value.

impl NativeElement for CurveElem

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 NativeScope for CurveElem

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

The constructor function for the type, if any.

fn scope() -> Scope

Get the associated scope for the type.

impl PartialEq for CurveElem

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 CurveElem

fn repr(&self) -> EcoString

Return the debug representation of the value.

impl Set for CurveElem

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

Parse relevant arguments into style properties for this element.