Struct druid::piet::kurbo::BezPath

pub struct BezPath(_);

A path that can Bézier segments up to cubic, possibly with multiple subpaths.

Methods

impl BezPath

pub fn new() -> BezPath

Create a new path.

pub fn from_vec(v: Vec<PathEl>) -> BezPath

Create a path from a vector of path elements.

BezPath also implements FromIterator<PathEl>, so it works with collect:

// a very contrived example:
use kurbo::{BezPath, PathEl};

let path = BezPath::new();
let as_vec: Vec<PathEl> = path.into_iter().collect();
let back_to_path: BezPath = as_vec.into_iter().collect();

pub fn push(&mut self, el: PathEl)

Push a generic path element onto the path.

pub fn move_to<P>(&mut self, p: P) where
    P: Into<Point>, 

Push a "move to" element onto the path.

pub fn line_to<P>(&mut self, p: P) where
    P: Into<Point>, 

Push a "line to" element onto the path.

pub fn quad_to<P>(&mut self, p1: P, p2: P) where
    P: Into<Point>, 

Push a "quad to" element onto the path.

pub fn curve_to<P>(&mut self, p1: P, p2: P, p3: P) where
    P: Into<Point>, 

Push a "curve to" element onto the path.

pub fn close_path(&mut self)

Push a "close path" element onto the path.

pub fn elements(&self) -> &[PathEl]

Get the path elements.

pub fn iter(&self) -> impl Iterator<Item = PathEl>

Returns an iterator over the path's elements.

pub fn segments(&self) -> impl Iterator<Item = PathSeg>

Iterate over the path segments.

pub fn get_seg(&self, ix: usize) -> Option<PathSeg>

Get the segment at the given element index.

The element index counts PathEl elements, so for example includes an initial Moveto.

pub fn is_empty(&self) -> bool

Returns true if the path contains no segments.

pub fn apply_affine(&mut self, affine: Affine)

Apply an affine transform to the path.

pub fn nearest(&self, p: Point, accuracy: f64) -> (usize, f64, f64)

Find the nearest point.

Panics if path is empty or invalid.

Note that the returned index counts segments, not elements. Thus, the initial Moveto is not counted. For a simple path consisting of a Moveto followed by Lineto/Quadto/Cubicto elements, the element index is the segment index + 1.

Returns the index of the segment, the parameter within that segment, and the square of the distance to the point.

impl BezPath

pub fn from_path_segments(segments: impl Iterator<Item = PathSeg>) -> BezPath

Create a BezPath with segments corresponding to the sequence of PathSegs

pub fn to_svg(&self) -> String

Convert the path to an SVG path string representation.

The current implementation doesn't take any special care to produce a short string (reducing precision, using relative movement).

pub fn write_to<W>(&self, writer: W) -> Result<(), Error> where
    W: Write, 

Write the SVG representation of this path to the provided buffer.

pub fn from_svg(data: &str) -> Result<BezPath, SvgParseError>

Try to parse a bezier path from an SVG path element.

This is implemented on a best-effort basis, intended for cases where the user controls the source of paths, and is not intended as a replacement for a general, robust SVG parser.

Trait Implementations

impl Clone for BezPath

fn clone(&self) -> BezPath

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Data for BezPath

fn same(&self, other: &Self) -> bool

Determine whether two values are the same.

impl Debug for BezPath

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

Formats the value using the given formatter.

impl Default for BezPath

fn default() -> BezPath

Returns the "default value" for a type.

impl FromIterator<PathEl> for BezPath

fn from_iter<T>(iter: T) -> BezPath where
    T: IntoIterator<Item = PathEl>, 

Creates a value from an iterator.

impl<'a> IntoIterator for &'a BezPath

type Item = PathEl

The type of the elements being iterated over.

type IntoIter = Cloned<Iter<'a, PathEl>>

Which kind of iterator are we turning this into?

fn into_iter(self) -> <&'a BezPath as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a> Mul<&'a BezPath> for TranslateScale

type Output = BezPath

The resulting type after applying the * operator.

fn mul(self, other: &BezPath) -> BezPath

Performs the * operation.

impl<'a> Mul<&'a BezPath> for Affine

type Output = BezPath

The resulting type after applying the * operator.

fn mul(self, other: &BezPath) -> BezPath

Performs the * operation.

impl Mul<BezPath> for Affine

type Output = BezPath

The resulting type after applying the * operator.

fn mul(self, other: BezPath) -> BezPath

Performs the * operation.

impl Mul<BezPath> for TranslateScale

type Output = BezPath

The resulting type after applying the * operator.

fn mul(self, other: BezPath) -> BezPath

Performs the * operation.

impl Shape for BezPath

type BezPathIter = IntoIter<PathEl>

The iterator resulting from to_bez_path.

fn to_bez_path(&self, _tolerance: f64) -> <BezPath as Shape>::BezPathIter

Convert to a Bézier path, as an iterator over path elements.

fn area(&self) -> f64

Signed area.

fn perimeter(&self, accuracy: f64) -> f64

Total length of perimeter.

fn winding(&self, pt: Point) -> i32

Winding number of point.

fn bounding_box(&self) -> Rect

The smallest rectangle that encloses the shape.

fn as_path_slice(&self) -> Option<&[PathEl]>

If the shape is stored as a slice of path elements, make that available.

fn into_bez_path(self, tolerance: f64) -> BezPath

Convert into a Bézier path.

fn as_line(&self) -> Option<Line>

If the shape is a line, make it available.

fn as_rect(&self) -> Option<Rect>

If the shape is a rectangle, make it available.

fn as_rounded_rect(&self) -> Option<RoundedRect>

If the shape is a rounded rectangle, make it available.

fn as_circle(&self) -> Option<Circle>

If the shape is a circle, make it available.