Struct tiny_skia::Canvas

pub struct Canvas {
    pub pixmap: Pixmap,
    // some fields omitted
}

Provides a high-level rendering API.

Unlike the most of other types, Canvas provides an unchecked API. Which means that a drawing command will simply be ignored in case of an error and a caller has no way of checking it.

Fields

pixmap: Pixmap

A pixmap owned by the canvas.

Implementations

impl Canvas

pub fn new(width: u32, height: u32) -> Option<Self>

Creates a new canvas.

A canvas is filled with transparent black by default, aka (0, 0, 0, 0).

Allocates a new pixmap. Use Canvas::from(pixmap) to reuse an existing one.

Zero size in an error.

Pixmap's width is limited by i32::MAX/4.

pub fn translate(&mut self, tx: f32, ty: f32)

Translates the canvas.

pub fn scale(&mut self, sx: f32, sy: f32)

Scales the canvas.

pub fn transform(
    &mut self,
    sx: f32,
    ky: f32,
    kx: f32,
    sy: f32,
    tx: f32,
    ty: f32
)

Applies an affine transformation to the canvas.

pub fn apply_transform(&mut self, ts: &Transform)

Applies an affine transformation to the canvas.

pub fn get_transform(&mut self) -> Transform

Gets the current canvas transform.

pub fn set_transform(&mut self, ts: Transform)

Sets the canvas transform.

pub fn reset_transform(&mut self)

Resets the canvas transform to identity.

pub fn set_clip_rect(&mut self, rect: Rect, anti_alias: bool)

Sets a clip rectangle.

Consecutive calls will replace the previous value.

Clipping is affected by the current transform.

pub fn set_clip_path(
    &mut self,
    path: &Path,
    fill_type: FillRule,
    anti_alias: bool
)

Sets a clip path.

Consecutive calls will replace the previous value.

Clipping is affected by the current transform.

pub fn reset_clip(&mut self)

Resets the current clip.

pub fn fill_path(&mut self, path: &Path, paint: &Paint<'_>, fill_type: FillRule)

Fills a path.

pub fn stroke_path(&mut self, path: &Path, paint: &Paint<'_>, stroke: &Stroke)

Strokes a path.

Stroking is implemented using two separate algorithms:

1. If a stroke width is wider than 1px (after applying the transformation), a path will be converted into a stroked path and then filled using Painter::fill_path. Which means that we have to allocate a separate Path, that can be 2-3x larger then the original path. Canvas will reuse this allocation during subsequent strokes.
2. If a stroke width is thinner than 1px (after applying the transformation), we will use hairline stroking, which doesn't involve a separate path allocation.

Also, if a stroke has a dash array, then path will be converted into a dashed path first and then stroked. Which means a yet another allocation.

pub fn draw_pixmap(
    &mut self,
    x: i32,
    y: i32,
    pixmap: &Pixmap,
    paint: &PixmapPaint
)

Draws a Pixmap on top of the current Pixmap.

We basically filling a rectangle with a pixmap pattern.

pub fn fill_rect(&mut self, rect: Rect, paint: &Paint<'_>)

Fills a rectangle.

If there is no transform - uses Painter::fill_rect. Otherwise, it is just a Canvas::fill_path with a rectangular path.

Trait Implementations

impl Clone for Canvas

fn clone(&self) -> Canvas

Returns a copy of the value.

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

Performs copy-assignment from source.

impl From<Pixmap> for Canvas

fn from(pixmap: Pixmap) -> Self

Performs the conversion.