Struct tiny_skia_path::PathBuilder

pub struct PathBuilder {
    pub(crate) verbs: Vec<PathVerb>,
    pub(crate) points: Vec<Point>,
    pub(crate) last_move_to_index: usize,
    pub(crate) move_to_required: bool,
}

A path builder.

Fields

verbs: Vec<PathVerb>

points: Vec<Point>

last_move_to_index: usize

move_to_required: bool

Implementations

impl PathBuilder

pub fn new() -> Self

Creates a new builder.

pub fn with_capacity(verbs_capacity: usize, points_capacity: usize) -> Self

Creates a new builder with a specified capacity.

Number of points depends on a verb type:

• Move - 1
• Line - 1
• Quad - 2
• Cubic - 3
• Close - 0

pub fn from_rect(rect: Rect) -> Path

Creates a new Path from Rect.

Never fails since Rect is always valid.

Segments are created clockwise: TopLeft -> TopRight -> BottomRight -> BottomLeft

The contour is closed.

pub fn from_circle(cx: f32, cy: f32, radius: f32) -> Option<Path>

Creates a new Path from a circle.

See PathBuilder::push_circle for details.

pub fn from_oval(oval: Rect) -> Option<Path>

Creates a new Path from an oval.

See PathBuilder::push_oval for details.

pub(crate) fn reserve( &mut self, additional_verbs: usize, additional_points: usize, )

pub fn len(&self) -> usize

Returns the current number of segments in the builder.

pub fn is_empty(&self) -> bool

Checks if the builder has any segments added.

pub fn move_to(&mut self, x: f32, y: f32)

Adds beginning of a contour.

Multiple continuous MoveTo segments are not allowed. If the previous segment was also MoveTo, it will be overwritten with the current one.

fn inject_move_to_if_needed(&mut self)

pub fn line_to(&mut self, x: f32, y: f32)

Adds a line from the last point.

• If Path is empty - adds Move(0, 0) first.
• If Path ends with Close - adds Move(last_x, last_y) first.

pub fn quad_to(&mut self, x1: f32, y1: f32, x: f32, y: f32)

Adds a quad curve from the last point to x, y.

• If Path is empty - adds Move(0, 0) first.
• If Path ends with Close - adds Move(last_x, last_y) first.

pub(crate) fn quad_to_pt(&mut self, p1: Point, p: Point)

pub(crate) fn conic_to(&mut self, x1: f32, y1: f32, x: f32, y: f32, weight: f32)

pub(crate) fn conic_points_to(&mut self, pt1: Point, pt2: Point, weight: f32)

pub fn cubic_to(&mut self, x1: f32, y1: f32, x2: f32, y2: f32, x: f32, y: f32)

Adds a cubic curve from the last point to x, y.

• If Path is empty - adds Move(0, 0) first.
• If Path ends with Close - adds Move(last_x, last_y) first.

pub(crate) fn cubic_to_pt(&mut self, p1: Point, p2: Point, p: Point)

pub fn close(&mut self)

Closes the current contour.

A closed contour connects the first and the last Point with a line, forming a continuous loop.

Does nothing when Path is empty or already closed.

Open and closed contour will be filled the same way. Stroking an open contour will add LineCap at contour’s start and end. Stroking an closed contour will add LineJoin at contour’s start and end.

pub fn last_point(&self) -> Option<Point>

Returns the last point if any.

pub(crate) fn set_last_point(&mut self, pt: Point)

pub(crate) fn is_zero_length_since_point(&self, start_pt_index: usize) -> bool

pub fn push_rect(&mut self, rect: Rect)

Adds a rectangle contour.

The contour is closed and has a clock-wise direction.

pub fn push_oval(&mut self, oval: Rect)

Adds an oval contour bounded by the provided rectangle.

The contour is closed and has a clock-wise direction.

pub fn push_circle(&mut self, x: f32, y: f32, r: f32)

Adds a circle contour.

The contour is closed and has a clock-wise direction.

Does nothing when:

• radius <= 0
• any value is not finite or really large

pub fn push_path(&mut self, other: &Path)

Adds a path.

pub(crate) fn push_path_builder(&mut self, other: &PathBuilder)

pub(crate) fn reverse_path_to(&mut self, other: &PathBuilder)

Appends, in a reverse order, the first contour of path ignoring path’s last point.

pub fn clear(&mut self)

Reset the builder.

Memory is not deallocated.

pub fn finish(self) -> Option<Path>

Finishes the builder and returns a Path.

Returns None when Path is empty or has invalid bounds.

Trait Implementations

impl Clone for PathBuilder

fn clone(&self) -> PathBuilder

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for PathBuilder

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

Formats the value using the given formatter.

impl Default for PathBuilder

fn default() -> PathBuilder

Returns the “default value” for a type.