Enum PathSegment 

pub enum PathSegment {
    ToPoint {
        base: BasePath,
    },
    TangentialArcTo {
        base: BasePath,
        center: Point2d,
        ccw: bool,
    },
    Horizontal {
        base: BasePath,
        x: f64,
    },
    AngledLineTo {
        base: BasePath,
        x: Option<f64>,
        y: Option<f64>,
    },
    Base {
        base: BasePath,
    },
}

Paths are made up of multiple segments, laid out top-to-tail (i.e. the end of one segment is the start of the next).

Variants

ToPoint

A path that goes to a point.

Fields

base: BasePath

Defines the end point, and where the path segment to it started.

TangentialArcTo

A arc that is tangential to the last path segment that goes to a point

Fields

base: BasePath

Defines the end point, and where the path segment to it started.

center: Point2d

the arc’s center

ccw: bool

arc’s direction

Horizontal

A path that is horizontal.

Fields

base: BasePath

Defines the end point, and where the line to it started.

x: f64

The x coordinate.

AngledLineTo

An angled line to.

Fields

base: BasePath

Defines the end point, and where the line to it started.

x: Option<f64>

The x coordinate.

y: Option<f64>

The y coordinate.

Base

A base path.

Fields

base: BasePath

Defines the end point, and where the line to it started.

Implementations

impl PathSegment

pub fn segment_kind(&self) -> &'static str

What kind of segment?

Trait Implementations

impl Clone for PathSegment

fn clone(&self) -> PathSegment

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for PathSegment

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for PathSegment

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for PathSegment

fn eq(&self, other: &PathSegment) -> 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 Serialize for PathSegment

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Value for PathSegment

fn into_parts(self) -> Vec<Primitive>

Store the value in memory.

fn from_parts<I>(values: &mut I) -> Result<(Self, usize), MemoryError>

where I: Iterator<Item = Option<Primitive>>,

Read the value from memory.

impl StructuralPartialEq for PathSegment