Struct blend2d::path::Path

#[repr(transparent)]
pub struct Path { /* fields omitted */ }

Methods

impl Path

pub fn new() -> Self

pub fn with_capacity(n: usize) -> Self

pub fn clear(&mut self)

pub fn shrink_to_fit(&mut self)

pub fn reserve(&mut self, n: usize)

pub fn try_reserve(&mut self, n: usize) -> Result<()>

pub fn len(&self) -> usize

pub fn capacity(&self) -> usize

pub fn is_empty(&self) -> bool

pub fn command_data(&self) -> &[u8]

pub fn vertex_data(&self) -> &[PointD]

pub fn info_flags(&self) -> Result<PathFlags>

pub fn control_box(&self) -> Result<BoxD>

pub fn bounding_box(&self) -> Result<BoxD>

pub fn figure_range(&self, index: usize) -> Result<Range<usize>>

pub fn last_vertex(&self) -> Result<PointD>

pub fn closest_vertex(
    &self,
    p: &PointD,
    max_distance: f64
) -> Result<(usize, f64)>

pub fn hit_test(&self, p: &PointD, fill_rule: FillRule) -> Result<()>

pub fn set_vertex_at(
    &mut self,
    index: usize,
    cmd: PathCommand,
    x: f64,
    y: f64
) -> Result<()>

pub fn set_vertex_at_point(
    &mut self,
    index: usize,
    cmd: PathCommand,
    point: PointD
) -> Result<()>

impl Path

pub fn move_to(&mut self, x: f64, y: f64) -> Result<()>

pub fn move_to_point(&mut self, point: &PointD) -> Result<()>

pub fn line_to(&mut self, x: f64, y: f64) -> Result<()>

pub fn line_to_point(&mut self, point: &PointD) -> Result<()>

pub fn poly_to(&mut self, poly: &[PointD]) -> Result<()>

pub fn quad_to(&mut self, x1: f64, y1: f64, x2: f64, y2: f64) -> Result<()>

pub fn quad_to_points(
    &mut self,
    x1: f64,
    y1: f64,
    x2: f64,
    y2: f64
) -> Result<()>

pub fn cubic_to(
    &mut self,
    x1: f64,
    y1: f64,
    x2: f64,
    y2: f64,
    x3: f64,
    y3: f64
) -> Result<()>

pub fn cubic_to_points(
    &mut self,
    p1: &PointD,
    p2: &PointD,
    p3: &PointD
) -> Result<()>

pub fn smooth_quad_to(&mut self, x2: f64, y2: f64) -> Result<()>

pub fn smooth_quad_to_point(&mut self, p2: &PointD) -> Result<()>

pub fn smooth_cubic_to(
    &mut self,
    x2: f64,
    y2: f64,
    x3: f64,
    y3: f64
) -> Result<()>

pub fn smooth_cubic_to_points(&mut self, p2: &PointD, p3: &PointD) -> Result<()>

pub fn arc_to(
    &mut self,
    cx: f64,
    cy: f64,
    rx: f64,
    ry: f64,
    start: f64,
    sweep: f64,
    force_move_to: bool
) -> Result<()>

pub fn arc_to_points(
    &mut self,
    cp: &PointD,
    rp: &PointD,
    start: f64,
    sweep: f64,
    force_move_to: bool
) -> Result<()>

pub fn arc_quadrant_to(
    &mut self,
    x1: f64,
    y1: f64,
    x2: f64,
    y2: f64
) -> Result<()>

pub fn arc_quadrant_to_points(&mut self, p1: &PointD, p2: &PointD) -> Result<()>

pub fn elliptic_arc_to(
    &mut self,
    rx: f64,
    ry: f64,
    x_axis_rotation: f64,
    large_arc_flag: bool,
    sweep_flag: bool,
    x1: f64,
    y1: f64
) -> Result<()>

pub fn elliptic_arc_to_points(
    &mut self,
    rp: &PointD,
    x_axis_rotation: f64,
    large_arc_flag: bool,
    sweep_flag: bool,
    p1: &PointD
) -> Result<()>

pub fn close(&mut self) -> Result<()>

impl Path

pub fn add_geometry<T: Geometry + ?Sized>(
    &mut self,
    g: &T,
    matrix: Option<&Matrix2D>,
    dir: GeometryDirection
) -> Result<()>

pub fn add_polygon<R, P>(
    &mut self,
    p: R,
    matrix: Option<&Matrix2D>,
    dir: GeometryDirection
) -> Result<()> where
    R: AsRef<[P]>,
    P: Point + Geometry, 

pub fn add_polyline<R, P>(
    &mut self,
    p: R,
    matrix: Option<&Matrix2D>,
    dir: GeometryDirection
) -> Result<()> where
    R: AsRef<[P]>,
    P: Point, 

pub fn add_path(&mut self, other: &Path) -> Result<()>

pub fn add_path_range<R: RangeBounds<usize>>(
    &mut self,
    other: &Path,
    range: R
) -> Result<()>

pub fn add_translated_path(&mut self, other: &Path, p: &PointD) -> Result<()>

pub fn add_translated_path_range<R: RangeBounds<usize>>(
    &mut self,
    other: &Path,
    range: R,
    p: &PointD
) -> Result<()>

pub fn add_transformed_path(&mut self, other: &Path, m: &Matrix2D) -> Result<()>

pub fn add_transformed_path_range<R: RangeBounds<usize>>(
    &mut self,
    other: &Path,
    range: R,
    m: &Matrix2D
) -> Result<()>

pub fn add_reversed_path(
    &mut self,
    other: &Path,
    mode: PathReverseMode
) -> Result<()>

pub fn add_reversed_path_range<R: RangeBounds<usize>>(
    &mut self,
    other: &Path,
    range: R,
    mode: PathReverseMode
) -> Result<()>

pub fn add_stroked_path(
    &mut self,
    other: &Path,
    options: &StrokeOptions,
    approx: &ApproximationOptions
) -> Result<()>

pub fn add_stroked_path_range<R: RangeBounds<usize>>(
    &mut self,
    other: &Path,
    range: R,
    options: &StrokeOptions,
    approx: &ApproximationOptions
) -> Result<()>

impl Path

pub fn translate(&mut self, p: &PointD) -> Result<()>

pub fn translate_range<R: RangeBounds<usize>>(
    &mut self,
    range: R,
    p: &PointD
) -> Result<()>

pub fn transform(&mut self, m: &Matrix2D) -> Result<()>

pub fn transform_range<R: RangeBounds<usize>>(
    &mut self,
    range: R,
    m: &Matrix2D
) -> Result<()>

pub fn fit_to(&mut self, rect: &RectD, flags: PathFitFlags) -> Result<()>

pub fn fit_to_range<R: RangeBounds<usize>>(
    &mut self,
    range: R,
    rect: &RectD,
    flags: PathFitFlags
) -> Result<()>

Trait Implementations

impl ArrayType for Path

const IMPL_IDX: usize

impl Geometry for Path

const GEO_TYPE: u32

impl Drop for Path

fn drop(&mut self)

Executes the destructor for this type.

impl PartialEq<Path> for Path

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

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

#[must_use]

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

This method tests for !=.

impl Clone for Path

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Default for Path

fn default() -> Self

Returns the "default value" for a type.