Struct freya_engine::prelude::svg::Canvas

pub struct Canvas { /* private fields */ }

Implementations§

§

impl Canvas

pub fn new(bounds: impl AsRef<Rect>, flags: impl Into<Option<Flags>>) -> Canvas

Creates a new SVG canvas.

pub fn end(self) -> RCHandle<SkData>

Ends the Canvas drawing and returns the resulting SVG. TODO: rename to into_svg() or into_svg_data()?

Methods from Deref<Target = Canvas>§

pub fn annotate_rect_with_url( &mut self, rect: impl AsRef<Rect>, data: &RCHandle<SkData> ) -> &mut Canvas

pub fn annotate_named_destination( &mut self, point: impl Into<Point>, data: &RCHandle<SkData> ) -> &mut Canvas

pub fn annotate_link_to_destination( &mut self, rect: impl AsRef<Rect>, data: &RCHandle<SkData> ) -> &mut Canvas

pub fn image_info(&self) -> Handle<SkImageInfo>

Returns [ImageInfo] for Canvas. If Canvas is not associated with raster surface or GPU surface, returned crate::ColorType is set to crate::ColorType::Unknown

Returns dimensions and crate::ColorType of Canvas

example: https://fiddle.skia.org/c/@Canvas_imageInfo

pub fn props(&self) -> Option<SurfaceProps>

Copies [SurfaceProps], if Canvas is associated with raster surface or GPU surface, and returns true. Otherwise, returns false and leave props unchanged.

props storage for writable [SurfaceProps] Returns true if [SurfaceProps] was copied

example: https://fiddle.skia.org/c/@Canvas_getProps

pub fn base_props(&self) -> SurfaceProps

Returns the [SurfaceProps] associated with the canvas (i.e., at the base of the layer stack).

pub fn top_props(&self) -> SurfaceProps

Returns the [SurfaceProps] associated with the canvas that are currently active (i.e., at the top of the layer stack). This can differ from Self::base_props depending on the flags passed to saveLayer (see [SaveLayerFlags]).

pub fn flush(&mut self) -> &mut Canvas

👎Deprecated since 0.38.0: Replace usage with DirectContext::flush()

Triggers the immediate execution of all pending draw operations. If Canvas is associated with GPU surface, resolves all pending GPU operations. If Canvas is associated with raster surface, has no effect; raster draw operations are never deferred.

DEPRECATED: Replace usage with GrDirectContext::flush()

pub fn base_layer_size(&self) -> ISize

Gets the size of the base or root layer in global canvas coordinates. The origin of the base layer is always (0,0). The area available for drawing may be smaller (due to clipping or saveLayer).

Returns integral size of base layer

example: https://fiddle.skia.org/c/@Canvas_getBaseLayerSize

pub fn new_surface( &mut self, info: &Handle<SkImageInfo>, props: Option<&SurfaceProps> ) -> Option<RCHandle<SkSurface>>

Creates Surface matching info and props, and associates it with Canvas. Returns None if no match found.

If props is None, matches [SurfaceProps] in Canvas. If props is None and Canvas does not have [SurfaceProps], creates Surface with default [SurfaceProps].

info width, height, crate::ColorType, [crate::AlphaType], and crate::ColorSpace
props [SurfaceProps] to match; may be None to match Canvas Returns Surface matching info and props, or None if no match is available

example: https://fiddle.skia.org/c/@Canvas_makeSurface

pub fn recording_context(&mut self) -> Option<RCHandle<GrRecordingContext>>

Returns GPU context of the GPU surface associated with Canvas.

Returns GPU context, if available; None otherwise

example: https://fiddle.skia.org/c/@Canvas_recordingContext

pub fn direct_context(&mut self) -> Option<RCHandle<GrDirectContext>>

Returns the gpu::DirectContext. This is a rust-skia helper for that makes it simpler to call [Image::encode].

pub unsafe fn surface(&mut self) -> Option<RCHandle<SkSurface>>

Sometimes a canvas is owned by a surface. If it is, Self::surface() will return a bare pointer to that surface, else this will return None.

Safety

This function is unsafe because it is not clear how exactly the lifetime of the canvas relates to surface returned. See also [OwnedCanvas], [RCHandle<SkSurface>::canvas()].

pub fn access_top_layer_pixels(&mut self) -> Option<TopLayerPixels<'_>>

Returns the pixel base address, [ImageInfo], row_bytes, and origin if the pixels can be read directly.

info storage for writable pixels’ [ImageInfo]
row_bytes storage for writable pixels’ row bytes
origin storage for Canvas top layer origin, its top-left corner Returns address of pixels, or None if inaccessible

example: https://fiddle.skia.org/c/@Canvas_accessTopLayerPixels_a example: https://fiddle.skia.org/c/@Canvas_accessTopLayerPixels_b

pub fn peek_pixels(&mut self) -> Option<Pixmap<'_>>

Returns true if Canvas has direct access to its pixels.

Pixels are readable when BaseDevice is raster. Pixels are not readable when Canvas is returned from GPU surface, returned by [crate::Document::begin_page()], returned by [Handle<SkPictureRecorder>::begin_recording()], or Canvas is the base of a utility class like DebugCanvas.

pixmap is valid only while Canvas is in scope and unchanged. Any Canvas or Surface call may invalidate the pixmap values.

Returns [Pixmap] if Canvas has direct access to pixels

example: https://fiddle.skia.org/c/@Canvas_peekPixels

pub fn read_pixels( &mut self, dst_info: &Handle<SkImageInfo>, dst_pixels: &mut [u8], dst_row_bytes: usize, src_point: impl Into<IPoint> ) -> bool

Copies Rect of pixels from Canvas into dst_pixels. Matrix and clip are ignored.

Source Rect corners are src_point and (image_info().width(), image_info().height()). Destination Rect corners are (0, 0) and (dst_Info.width(), dst_info.height()). Copies each readable pixel intersecting both rectangles, without scaling, converting to dst_info.color_type() and dst_info.alpha_type() if required.

Pixels are readable when BaseDevice is raster, or backed by a GPU. Pixels are not readable when Canvas is returned by [crate::Document::begin_page()], returned by [Handle<SkPictureRecorder>::begin_recording()], or Canvas is the base of a utility class like DebugCanvas.

The destination pixel storage must be allocated by the caller.

Pixel values are converted only if crate::ColorType and [crate::AlphaType] do not match. Only pixels within both source and destination rectangles are copied. dst_pixels contents outside Rect intersection are unchanged.

Pass negative values for src_point.x or src_point.y to offset pixels across or down destination.

Does not copy, and returns false if:

Source and destination rectangles do not intersect.
Canvas pixels could not be converted to dst_info.color_type() or dst_info.alpha_type().
Canvas pixels are not readable; for instance, Canvas is document-based.
dst_row_bytes is too small to contain one row of pixels.
dst_info width, height, crate::ColorType, and [crate::AlphaType] of dstPixels
dst_pixels storage for pixels; dst_info.height() times dst_row_bytes, or larger
dst_row_bytes size of one destination row; dst_info.width() times pixel size, or larger
src_point offset into readable pixels; may be negative Returns true if pixels were copied

pub fn read_pixels_to_pixmap( &mut self, pixmap: &mut Pixmap<'_>, src: impl Into<IPoint> ) -> bool

Copies Rect of pixels from Canvas into pixmap. Matrix and clip are ignored.

Source Rect corners are (src.x, src.y) and (image_info().width(), image_info().height()). Destination Rect corners are (0, 0) and (pixmap.width(), pixmap.height()). Copies each readable pixel intersecting both rectangles, without scaling, converting to pixmap.color_type() and pixmap.alpha_type() if required.

Pixels are readable when BaseDevice is raster, or backed by a GPU. Pixels are not readable when Canvas is returned by [crate::Document::begin_page()], returned by [Handle<SkPictureRecorder>::begin_recording()], or Canvas is the base of a utility class like DebugCanvas.

Caller must allocate pixel storage in pixmap if needed.

Pixel values are converted only if crate::ColorType and [crate::AlphaType] do not match. Only pixels within both source and destination Rect are copied. pixmap pixels contents outside Rect intersection are unchanged.

Pass negative values for src.x or src.y to offset pixels across or down pixmap.

Does not copy, and returns false if:

Source and destination rectangles do not intersect.
Canvas pixels could not be converted to pixmap.color_type() or pixmap.alpha_type().
Canvas pixels are not readable; for instance, Canvas is document-based.
[Pixmap] pixels could not be allocated.
pixmap.row_bytes() is too small to contain one row of pixels.
pixmap storage for pixels copied from Canvas
src offset into readable pixels ; may be negative Returns true if pixels were copied

example: https://fiddle.skia.org/c/@Canvas_readPixels_2

pub fn read_pixels_to_bitmap( &mut self, bitmap: &mut Handle<SkBitmap>, src: impl Into<IPoint> ) -> bool

Copies Rect of pixels from Canvas into bitmap. Matrix and clip are ignored.

Source Rect corners are (src.x, src.y) and (image_info().width(), image_info().height()). Destination Rect corners are (0, 0) and (bitmap.width(), bitmap.height()). Copies each readable pixel intersecting both rectangles, without scaling, converting to bitmap.color_type() and bitmap.alpha_type() if required.

Pixels are readable when BaseDevice is raster, or backed by a GPU. Pixels are not readable when Canvas is returned by [crate::Document::begin_page()], returned by [Handle<SkPictureRecorder>::begin_recording()], or Canvas is the base of a utility class like DebugCanvas.

Caller must allocate pixel storage in bitmap if needed.

[Bitmap] values are converted only if crate::ColorType and [crate::AlphaType] do not match. Only pixels within both source and destination rectangles are copied. [Bitmap] pixels outside Rect intersection are unchanged.

Pass negative values for srcX or srcY to offset pixels across or down bitmap.

Does not copy, and returns false if:

Source and destination rectangles do not intersect.
Canvas pixels could not be converted to bitmap.color_type() or bitmap.alpha_type().
Canvas pixels are not readable; for instance, Canvas is document-based.
bitmap pixels could not be allocated.
bitmap.row_bytes() is too small to contain one row of pixels.
bitmap storage for pixels copied from Canvas
src offset into readable pixels; may be negative Returns true if pixels were copied

example: https://fiddle.skia.org/c/@Canvas_readPixels_3

pub fn write_pixels( &mut self, info: &Handle<SkImageInfo>, pixels: &[u8], row_bytes: usize, offset: impl Into<IPoint> ) -> bool

Copies Rect from pixels to Canvas. Matrix and clip are ignored. Source Rect corners are (0, 0) and (info.width(), info.height()). Destination Rect corners are (offset.x, offset.y) and (image_info().width(), image_info().height()).

Copies each readable pixel intersecting both rectangles, without scaling, converting to image_info().color_type() and image_info().alpha_type() if required.

Pixels are writable when BaseDevice is raster, or backed by a GPU. Pixels are not writable when Canvas is returned by [crate::Document::begin_page()], returned by [Handle<SkPictureRecorder>::begin_recording()], or Canvas is the base of a utility class like DebugCanvas.

Pixel values are converted only if crate::ColorType and [crate::AlphaType] do not match. Only pixels within both source and destination rectangles are copied. Canvas pixels outside Rect intersection are unchanged.

Pass negative values for offset.x or offset.y to offset pixels to the left or above Canvas pixels.

Does not copy, and returns false if:

Source and destination rectangles do not intersect.
pixels could not be converted to Canvas image_info().color_type() or image_info().alpha_type().
Canvas pixels are not writable; for instance, Canvas is document-based.
row_bytes is too small to contain one row of pixels.
info width, height, crate::ColorType, and [crate::AlphaType] of pixels
pixels pixels to copy, of size info.height() times row_bytes, or larger
row_bytes size of one row of pixels; info.width() times pixel size, or larger
offset offset into Canvas writable pixels; may be negative Returns true if pixels were written to Canvas

example: https://fiddle.skia.org/c/@Canvas_writePixels

pub fn write_pixels_from_bitmap( &mut self, bitmap: &Handle<SkBitmap>, offset: impl Into<IPoint> ) -> bool

Copies Rect from pixels to Canvas. Matrix and clip are ignored. Source Rect corners are (0, 0) and (bitmap.width(), bitmap.height()).

Destination Rect corners are (offset.x, offset.y) and (image_info().width(), image_info().height()).

Copies each readable pixel intersecting both rectangles, without scaling, converting to image_info().color_type() and image_info().alpha_type() if required.

Pixels are writable when BaseDevice is raster, or backed by a GPU. Pixels are not writable when Canvas is returned by [crate::Document::begin_page()], returned by [Handle<SkPictureRecorder>::begin_recording()], or Canvas is the base of a utility class like DebugCanvas.

Pixel values are converted only if crate::ColorType and [crate::AlphaType] do not match. Only pixels within both source and destination rectangles are copied. Canvas pixels outside Rect intersection are unchanged.

Pass negative values for offset to offset pixels to the left or above Canvas pixels.

Does not copy, and returns false if:

Source and destination rectangles do not intersect.
bitmap does not have allocated pixels.
bitmap pixels could not be converted to Canvas image_info().color_type() or image_info().alpha_type().
Canvas pixels are not writable; for instance, Canvas is document based.
bitmap pixels are inaccessible; for instance, bitmap wraps a texture.
bitmap contains pixels copied to Canvas
offset offset into Canvas writable pixels; may be negative Returns true if pixels were written to Canvas

example: https://fiddle.skia.org/c/@Canvas_writePixels_2 example: https://fiddle.skia.org/c/@State_Stack_a example: https://fiddle.skia.org/c/@State_Stack_b

pub fn save(&mut self) -> usize

Saves Matrix and clip. Calling Self::restore() discards changes to Matrix and clip, restoring the Matrix and clip to their state when Self::save() was called.

Matrix may be changed by Self::translate(), Self::scale(), Self::rotate(), Self::skew(), Self::concat(), Self::set_matrix(), and Self::reset_matrix(). Clip may be changed by Self::clip_rect(), Self::clip_rrect(), Self::clip_path(), Self::clip_region().

Saved Canvas state is put on a stack; multiple calls to Self::save() should be balance by an equal number of calls to Self::restore().

Call Self::restore_to_count() with result to restore this and subsequent saves.

Returns depth of saved stack

example: https://fiddle.skia.org/c/@Canvas_save

pub fn save_layer_alpha_f( &mut self, bounds: impl Into<Option<Rect>>, alpha: f32 ) -> usize

Saves Matrix and clip, and allocates Surface for subsequent drawing.

Calling Self::restore() discards changes to Matrix and clip, and blends layer with alpha opacity onto prior layer.

Matrix may be changed by Self::translate(), Self::scale(), Self::rotate(), Self::skew(), Self::concat(), Self::set_matrix(), and Self::reset_matrix(). Clip may be changed by Self::clip_rect(), Self::clip_rrect(), Self::clip_path(), Self::clip_region().

Rect bounds suggests but does not define layer size. To clip drawing to a specific rectangle, use Self::clip_rect().

alpha of zero is fully transparent, 1.0 is fully opaque.

Call Self::restore_to_count() with result to restore this and subsequent saves.

bounds hint to limit the size of layer; may be None
alpha opacity of layer Returns depth of saved stack

example: https://fiddle.skia.org/c/@Canvas_saveLayerAlpha

pub fn save_layer_alpha( &mut self, bounds: impl Into<Option<Rect>>, alpha: u32 ) -> usize

Helper that accepts an int between 0 and 255, and divides it by 255.0

pub fn save_layer(&mut self, layer_rec: &SaveLayerRec<'_>) -> usize

Saves Matrix and clip, and allocates Surface for subsequent drawing.

Calling Self::restore() discards changes to Matrix and clip, and blends Surface with alpha opacity onto the prior layer.

Matrix may be changed by Self::translate(), Self::scale(), Self::rotate(), Self::skew(), Self::concat(), Self::set_matrix(), and Self::reset_matrix(). Clip may be changed by Self::clip_rect(), Self::clip_rrect(), Self::clip_path(), Self::clip_region().

[SaveLayerRec] contains the state used to create the layer.

Call Self::restore_to_count() with result to restore this and subsequent saves.

layer_rec layer state Returns depth of save state stack before this call was made.

example: https://fiddle.skia.org/c/@Canvas_saveLayer_3

pub fn restore(&mut self) -> &mut Canvas

Removes changes to Matrix and clip since Canvas state was last saved. The state is removed from the stack.

Does nothing if the stack is empty.

example: https://fiddle.skia.org/c/@AutoCanvasRestore_restore

example: https://fiddle.skia.org/c/@Canvas_restore

pub fn save_count(&self) -> usize

Returns the number of saved states, each containing: Matrix and clip. Equals the number of Self::save() calls less the number of Self::restore() calls plus one. The save count of a new canvas is one.

Returns depth of save state stack

example: https://fiddle.skia.org/c/@Canvas_getSaveCount

pub fn restore_to_count(&mut self, save_count: usize) -> &mut Canvas

Restores state to Matrix and clip values when Self::save(), Self::save_layer(), or Self::save_layer_alpha() returned save_count.

Does nothing if save_count is greater than state stack count. Restores state to initial values if save_count is less than or equal to one.

saveCount depth of state stack to restore

example: https://fiddle.skia.org/c/@Canvas_restoreToCount

pub fn translate(&mut self, d: impl Into<Point>) -> &mut Canvas

Translates Matrix by d.

Mathematically, replaces Matrix with a translation matrix premultiplied with Matrix.

This has the effect of moving the drawing by (d.x, d.y) before transforming the result with Matrix.

d distance to translate

example: https://fiddle.skia.org/c/@Canvas_translate

pub fn scale(&mut self, _: (f32, f32)) -> &mut Canvas

Scales Matrix by sx on the x-axis and sy on the y-axis.

Mathematically, replaces Matrix with a scale matrix premultiplied with Matrix.

This has the effect of scaling the drawing by (sx, sy) before transforming the result with Matrix.

sx amount to scale on x-axis
sy amount to scale on y-axis

example: https://fiddle.skia.org/c/@Canvas_scale

pub fn rotate(&mut self, degrees: f32, p: Option<Point>) -> &mut Canvas

Rotates Matrix by degrees about a point at (p.x, p.y). Positive degrees rotates clockwise.

Mathematically, constructs a rotation matrix; premultiplies the rotation matrix by a translation matrix; then replaces Matrix with the resulting matrix premultiplied with Matrix.

This has the effect of rotating the drawing about a given point before transforming the result with Matrix.

degrees amount to rotate, in degrees
p the point to rotate about

example: https://fiddle.skia.org/c/@Canvas_rotate_2

pub fn skew(&mut self, _: (f32, f32)) -> &mut Canvas

Skews Matrix by sx on the x-axis and sy on the y-axis. A positive value of sx skews the drawing right as y-axis values increase; a positive value of sy skews the drawing down as x-axis values increase.

Mathematically, replaces Matrix with a skew matrix premultiplied with Matrix.

This has the effect of skewing the drawing by (sx, sy) before transforming the result with Matrix.

sx amount to skew on x-axis
sy amount to skew on y-axis

example: https://fiddle.skia.org/c/@Canvas_skew

pub fn concat(&mut self, matrix: &Matrix) -> &mut Canvas

Replaces Matrix with matrix premultiplied with existing Matrix.

This has the effect of transforming the drawn geometry by matrix, before transforming the result with existing Matrix.

matrix matrix to premultiply with existing Matrix

example: https://fiddle.skia.org/c/@Canvas_concat

pub fn concat_44(&mut self, m: &M44) -> &mut Canvas

pub fn set_matrix(&mut self, matrix: &M44) -> &mut Canvas

Replaces Matrix with matrix. Unlike Self::concat(), any prior matrix state is overwritten.

matrix matrix to copy, replacing existing Matrix

example: https://fiddle.skia.org/c/@Canvas_setMatrix

pub fn reset_matrix(&mut self) -> &mut Canvas

Sets Matrix to the identity matrix. Any prior matrix state is overwritten.

example: https://fiddle.skia.org/c/@Canvas_resetMatrix

pub fn clip_rect( &mut self, rect: impl AsRef<Rect>, op: impl Into<Option<SkClipOp>>, do_anti_alias: impl Into<Option<bool>> ) -> &mut Canvas

Replaces clip with the intersection or difference of clip and rect, with an aliased or anti-aliased clip edge. rect is transformed by Matrix before it is combined with clip.

rect Rect to combine with clip
op ClipOp to apply to clip
do_anti_alias true if clip is to be anti-aliased

example: https://fiddle.skia.org/c/@Canvas_clipRect

pub fn clip_irect( &mut self, irect: impl AsRef<IRect>, op: impl Into<Option<SkClipOp>> ) -> &mut Canvas

pub fn clip_rrect( &mut self, rrect: impl AsRef<RRect>, op: impl Into<Option<SkClipOp>>, do_anti_alias: impl Into<Option<bool>> ) -> &mut Canvas

Replaces clip with the intersection or difference of clip and rrect, with an aliased or anti-aliased clip edge. rrect is transformed by Matrix before it is combined with clip.

rrect RRect to combine with clip
op ClipOp to apply to clip
do_anti_alias true if clip is to be anti-aliased

example: https://fiddle.skia.org/c/@Canvas_clipRRect

pub fn clip_path( &mut self, path: &Handle<SkPath>, op: impl Into<Option<SkClipOp>>, do_anti_alias: impl Into<Option<bool>> ) -> &mut Canvas

Replaces clip with the intersection or difference of clip and path, with an aliased or anti-aliased clip edge. [crate::path::FillType] determines if path describes the area inside or outside its contours; and if path contour overlaps itself or another path contour, whether the overlaps form part of the area. path is transformed by Matrix before it is combined with clip.

path Path to combine with clip
op ClipOp to apply to clip
do_anti_alias true if clip is to be anti-aliased

example: https://fiddle.skia.org/c/@Canvas_clipPath

pub fn clip_shader( &mut self, shader: impl Into<RCHandle<SkShader>>, op: impl Into<Option<SkClipOp>> ) -> &mut Canvas

pub fn clip_region( &mut self, device_rgn: &Handle<SkRegion>, op: impl Into<Option<SkClipOp>> ) -> &mut Canvas

Replaces clip with the intersection or difference of clip and [Region] device_rgn. Resulting clip is aliased; pixels are fully contained by the clip. device_rgn is unaffected by Matrix.

device_rgn [Region] to combine with clip
op ClipOp to apply to clip

example: https://fiddle.skia.org/c/@Canvas_clipRegion

pub fn local_clip_bounds(&self) -> Option<Rect>

Returns bounds of clip, transformed by inverse of Matrix. If clip is empty, return Rect::new_empty(), where all Rect sides equal zero.

Rect returned is outset by one to account for partial pixel coverage if clip is anti-aliased.

Returns bounds of clip in local coordinates

example: https://fiddle.skia.org/c/@Canvas_getLocalClipBounds

pub fn device_clip_bounds(&self) -> Option<IRect>

Returns IRect bounds of clip, unaffected by Matrix. If clip is empty, return Rect::new_empty(), where all Rect sides equal zero.

Unlike Self::local_clip_bounds(), returned IRect is not outset.

Returns bounds of clip in BaseDevice coordinates

example: https://fiddle.skia.org/c/@Canvas_getDeviceClipBounds

pub fn draw_color( &mut self, color: impl Into<Color4f>, mode: impl Into<Option<SkBlendMode>> ) -> &mut Canvas

Fills clip with color color. mode determines how ARGB is combined with destination.

color [Color4f] representing unpremultiplied color.
mode [BlendMode] used to combine source color and destination

pub fn clear(&mut self, color: impl Into<Color4f>) -> &mut Canvas

Fills clip with color color using [BlendMode::Src]. This has the effect of replacing all pixels contained by clip with color.

color [Color4f] representing unpremultiplied color.

pub fn discard(&mut self) -> &mut Canvas

Makes Canvas contents undefined. Subsequent calls that read Canvas pixels, such as drawing with [BlendMode], return undefined results. discard() does not change clip or Matrix.

discard() may do nothing, depending on the implementation of Surface or BaseDevice that created Canvas.

discard() allows optimized performance on subsequent draws by removing cached data associated with Surface or BaseDevice. It is not necessary to call discard() once done with Canvas; any cached data is deleted when owning Surface or BaseDevice is deleted.

pub fn draw_paint(&mut self, paint: &Handle<SkPaint>) -> &mut Canvas

Fills clip with Paint paint. Paint components, Shader, [crate::ColorFilter], [ImageFilter], and [BlendMode] affect drawing; crate::MaskFilter and [crate::PathEffect] in paint are ignored.

paint graphics state used to fill Canvas

example: https://fiddle.skia.org/c/@Canvas_drawPaint

pub fn draw_points( &mut self, mode: SkCanvas_PointMode, pts: &[Point], paint: &Handle<SkPaint> ) -> &mut Canvas

Draws pts using clip, Matrix and Paint pain. if the number of points is less than one, has no effect. mode may be one of: [PointMode::Points], [PointMode::Lines], or [PointMode::Polygon]

If mode is [PointMode::Points], the shape of point drawn depends on paint [crate::paint::Cap]. If paint is set to [crate::paint::Cap::Round], each point draws a circle of diameter Paint stroke width. If paint is set to [crate::paint::Cap::Square] or [crate::paint::Cap::Butt], each point draws a square of width and height Paint stroke width.

If mode is [PointMode::Lines], each pair of points draws a line segment. One line is drawn for every two points; each point is used once. If count is odd, the final point is ignored.

If mode is [PointMode::Polygon], each adjacent pair of points draws a line segment. count minus one lines are drawn; the first and last point are used once.

Each line segment respects paint [crate::paint::Cap] and Paint stroke width. crate::paint::Style is ignored, as if were set to crate::paint::Style::Stroke.

Always draws each element one at a time; is not affected by [crate::paint::Join], and unlike Self::draw_path(), does not create a mask from all points and lines before drawing.

mode whether pts draws points or lines
pts array of points to draw
paint stroke, blend, color, and so on, used to draw

example: https://fiddle.skia.org/c/@Canvas_drawPoints

pub fn draw_point( &mut self, p: impl Into<Point>, paint: &Handle<SkPaint> ) -> &mut Canvas

Draws point p using clip, Matrix and Paint paint.

The shape of point drawn depends on paint [crate::paint::Cap]. If paint is set to [crate::paint::Cap::Round], draw a circle of diameter Paint stroke width. If paint is set to [crate::paint::Cap::Square] or [crate::paint::Cap::Butt], draw a square of width and height Paint stroke width. crate::paint::Style is ignored, as if were set to crate::paint::Style::Stroke.

p top-left edge of circle or square
paint stroke, blend, color, and so on, used to draw

pub fn draw_line( &mut self, p1: impl Into<Point>, p2: impl Into<Point>, paint: &Handle<SkPaint> ) -> &mut Canvas

Draws line segment from p1 to p2 using clip, Matrix, and Paint paint. In paint: Paint stroke width describes the line thickness; [crate::paint::Cap] draws the end rounded or square; crate::paint::Style is ignored, as if were set to crate::paint::Style::Stroke.

p1 start of line segment
p2 end of line segment
paint stroke, blend, color, and so on, used to draw

pub fn draw_rect( &mut self, rect: impl AsRef<Rect>, paint: &Handle<SkPaint> ) -> &mut Canvas

Draws Rect rect using clip, Matrix, and Paint paint. In paint: crate::paint::Style determines if rectangle is stroked or filled; if stroked, Paint stroke width describes the line thickness, and [crate::paint::Join] draws the corners rounded or square.

rect rectangle to draw
paint stroke or fill, blend, color, and so on, used to draw

example: https://fiddle.skia.org/c/@Canvas_drawRect

pub fn draw_irect( &mut self, rect: impl AsRef<IRect>, paint: &Handle<SkPaint> ) -> &mut Canvas

Draws IRect rect using clip, Matrix, and Paint paint. In paint: crate::paint::Style determines if rectangle is stroked or filled; if stroked, Paint stroke width describes the line thickness, and [crate::paint::Join] draws the corners rounded or square.

rect rectangle to draw
paint stroke or fill, blend, color, and so on, used to draw

pub fn draw_region( &mut self, region: &Handle<SkRegion>, paint: &Handle<SkPaint> ) -> &mut Canvas

Draws [Region] region using clip, Matrix, and Paint paint. In paint: crate::paint::Style determines if rectangle is stroked or filled; if stroked, Paint stroke width describes the line thickness, and [crate::paint::Join] draws the corners rounded or square.

region region to draw
paint Paint stroke or fill, blend, color, and so on, used to draw

example: https://fiddle.skia.org/c/@Canvas_drawRegion

pub fn draw_oval( &mut self, oval: impl AsRef<Rect>, paint: &Handle<SkPaint> ) -> &mut Canvas

Draws oval oval using clip, Matrix, and Paint. In paint: crate::paint::Style determines if oval is stroked or filled; if stroked, Paint stroke width describes the line thickness.

oval Rect bounds of oval
paint Paint stroke or fill, blend, color, and so on, used to draw

example: https://fiddle.skia.org/c/@Canvas_drawOval

pub fn draw_rrect( &mut self, rrect: impl AsRef<RRect>, paint: &Handle<SkPaint> ) -> &mut Canvas

Draws RRect rrect using clip, Matrix, and Paint paint. In paint: crate::paint::Style determines if rrect is stroked or filled; if stroked, Paint stroke width describes the line thickness.

rrect may represent a rectangle, circle, oval, uniformly rounded rectangle, or may have any combination of positive non-square radii for the four corners.

rrect RRect with up to eight corner radii to draw
paint Paint stroke or fill, blend, color, and so on, used to draw

example: https://fiddle.skia.org/c/@Canvas_drawRRect

pub fn draw_drrect( &mut self, outer: impl AsRef<RRect>, inner: impl AsRef<RRect>, paint: &Handle<SkPaint> ) -> &mut Canvas

Draws RRect outer and inner using clip, Matrix, and Paint paint. outer must contain inner or the drawing is undefined. In paint: crate::paint::Style determines if RRect is stroked or filled; if stroked, Paint stroke width describes the line thickness. If stroked and RRect corner has zero length radii, [crate::paint::Join] can draw corners rounded or square.

GPU-backed platforms optimize drawing when both outer and inner are concave and outer contains inner. These platforms may not be able to draw Path built with identical data as fast.

outer RRect outer bounds to draw
inner RRect inner bounds to draw
paint Paint stroke or fill, blend, color, and so on, used to draw

example: https://fiddle.skia.org/c/@Canvas_drawDRRect_a example: https://fiddle.skia.org/c/@Canvas_drawDRRect_b

pub fn draw_circle( &mut self, center: impl Into<Point>, radius: f32, paint: &Handle<SkPaint> ) -> &mut Canvas

Draws circle at center with radius using clip, Matrix, and Paint paint. If radius is zero or less, nothing is drawn. In paint: crate::paint::Style determines if circle is stroked or filled; if stroked, Paint stroke width describes the line thickness.

center circle center
radius half the diameter of circle
paint Paint stroke or fill, blend, color, and so on, used to draw

pub fn draw_arc( &mut self, oval: impl AsRef<Rect>, start_angle: f32, sweep_angle: f32, use_center: bool, paint: &Handle<SkPaint> ) -> &mut Canvas

Draws arc using clip, Matrix, and Paint paint.

Arc is part of oval bounded by oval, sweeping from start_angle to start_angle plus sweep_angle. start_angle and sweep_angle are in degrees.

start_angle of zero places start point at the right middle edge of oval. A positive sweep_angle places arc end point clockwise from start point; a negative sweep_angle places arc end point counterclockwise from start point. sweep_angle may exceed 360 degrees, a full circle. If use_center is true, draw a wedge that includes lines from oval center to arc end points. If use_center is false, draw arc between end points.

If Rect oval is empty or sweep_angle is zero, nothing is drawn.

oval Rect bounds of oval containing arc to draw
start_angle angle in degrees where arc begins
sweep_angle sweep angle in degrees; positive is clockwise
use_center if true, include the center of the oval
paint Paint stroke or fill, blend, color, and so on, used to draw

pub fn draw_round_rect( &mut self, rect: impl AsRef<Rect>, rx: f32, ry: f32, paint: &Handle<SkPaint> ) -> &mut Canvas

Draws RRect bounded by Rect rect, with corner radii (rx, ry) using clip, Matrix, and Paint paint.

In paint: crate::paint::Style determines if RRect is stroked or filled; if stroked, Paint stroke width describes the line thickness. If rx or ry are less than zero, they are treated as if they are zero. If rx plus ry exceeds rect width or rect height, radii are scaled down to fit. If rx and ry are zero, RRect is drawn as Rect and if stroked is affected by [crate::paint::Join].

rect Rect bounds of RRect to draw
rx axis length on x-axis of oval describing rounded corners
ry axis length on y-axis of oval describing rounded corners
paint stroke, blend, color, and so on, used to draw

example: https://fiddle.skia.org/c/@Canvas_drawRoundRect

pub fn draw_path( &mut self, path: &Handle<SkPath>, paint: &Handle<SkPaint> ) -> &mut Canvas

Draws Path path using clip, Matrix, and Paint paint. Path contains an array of path contour, each of which may be open or closed.

In paint: crate::paint::Style determines if RRect is stroked or filled: if filled, [crate::path::FillType] determines whether path contour describes inside or outside of fill; if stroked, Paint stroke width describes the line thickness, [crate::paint::Cap] describes line ends, and [crate::paint::Join] describes how corners are drawn.

path Path to draw
paint stroke, blend, color, and so on, used to draw

example: https://fiddle.skia.org/c/@Canvas_drawPath

pub fn draw_image( &mut self, image: impl AsRef<RCHandle<SkImage>>, left_top: impl Into<Point>, paint: Option<&Handle<SkPaint>> ) -> &mut Canvas

pub fn draw_image_rect( &mut self, image: impl AsRef<RCHandle<SkImage>>, src: Option<(&Rect, SkCanvas_SrcRectConstraint)>, dst: impl AsRef<Rect>, paint: &Handle<SkPaint> ) -> &mut Canvas

pub fn draw_image_with_sampling_options( &mut self, image: impl AsRef<RCHandle<SkImage>>, left_top: impl Into<Point>, sampling: impl Into<SamplingOptions>, paint: Option<&Handle<SkPaint>> ) -> &mut Canvas

pub fn draw_image_rect_with_sampling_options( &mut self, image: impl AsRef<RCHandle<SkImage>>, src: Option<(&Rect, SkCanvas_SrcRectConstraint)>, dst: impl AsRef<Rect>, sampling: impl Into<SamplingOptions>, paint: &Handle<SkPaint> ) -> &mut Canvas

pub fn draw_image_nine( &mut self, image: impl AsRef<RCHandle<SkImage>>, center: impl AsRef<IRect>, dst: impl AsRef<Rect>, filter_mode: SkFilterMode, paint: Option<&Handle<SkPaint>> ) -> &mut Canvas

Draws Image image stretched proportionally to fit into Rect dst. IRect center divides the image into nine sections: four sides, four corners, and the center. Corners are unmodified or scaled down proportionately if their sides are larger than dst; center and four sides are scaled to fit remaining space, if any.

Additionally transform draw using clip, Matrix, and optional Paint paint.

If Paint paint is supplied, apply [crate::ColorFilter], alpha, [ImageFilter], and [BlendMode]. If image is crate::ColorType::Alpha8, apply Shader. If paint contains crate::MaskFilter, generate mask from image bounds. Any crate::MaskFilter on paint is ignored as is paint anti-aliasing state.

If generated mask extends beyond image bounds, replicate image edge colors, just as Shader made from [RCHandle<Image>::to_shader()] with crate::TileMode::Clamp set replicates the image edge color when it samples outside of its bounds.

image Image containing pixels, dimensions, and format
center IRect edge of image corners and sides
dst destination Rect of image to draw to
filter what technique to use when sampling the image
paint Paint containing [BlendMode], [crate::ColorFilter], [ImageFilter], and so on; or None

pub fn draw_image_lattice( &mut self, image: impl AsRef<RCHandle<SkImage>>, lattice: &Lattice<'_>, dst: impl AsRef<Rect>, filter: SkFilterMode, paint: Option<&Handle<SkPaint>> ) -> &mut Canvas

Draws Image image stretched proportionally to fit into Rect dst.

[lattice::Lattice] lattice divides image into a rectangular grid. Each intersection of an even-numbered row and column is fixed; fixed lattice elements never scale larger than their initial size and shrink proportionately when all fixed elements exceed the bitmap dimension. All other grid elements scale to fill the available space, if any.

Additionally transform draw using clip, Matrix, and optional Paint paint.

If Paint paint is supplied, apply [crate::ColorFilter], alpha, [ImageFilter], and [BlendMode]. If image is crate::ColorType::Alpha8, apply Shader. If paint contains crate::MaskFilter, generate mask from image bounds. Any crate::MaskFilter on paint is ignored as is paint anti-aliasing state.

If generated mask extends beyond bitmap bounds, replicate bitmap edge colors, just as Shader made from SkShader::MakeBitmapShader with crate::TileMode::Clamp set replicates the bitmap edge color when it samples outside of its bounds.

image Image containing pixels, dimensions, and format
lattice division of bitmap into fixed and variable rectangles
dst destination Rect of image to draw to
filter what technique to use when sampling the image
paint Paint containing [BlendMode], [crate::ColorFilter], [ImageFilter], and so on; or None

pub fn draw_str( &mut self, str: impl AsRef<str>, origin: impl Into<Point>, font: &Handle<SkFont>, paint: &Handle<SkPaint> ) -> &mut Canvas

Draws String, with origin at (origin.x, origin.y), using clip, Matrix, [Font] font, and Paint paint.

This function uses the default character-to-glyph mapping from the crate::Typeface in font. It does not perform typeface fallback for characters not found in the crate::Typeface. It does not perform kerning; glyphs are positioned based on their default advances.

Text size is affected by Matrix and [Font] text size. Default text size is 12 point.

All elements of paint: [crate::PathEffect], crate::MaskFilter, Shader, [crate::ColorFilter], and [ImageFilter]; apply to text. By default, draws filled black glyphs.

str character code points drawn, ending with a char value of zero
origin start of string on x,y-axis
font typeface, text size and so, used to describe the text
paint blend, color, and so on, used to draw

pub fn draw_glyphs_utf8( &mut self, glyphs: &[u16], positions: &[Point], clusters: &[u32], utf8_text: impl AsRef<str>, origin: impl Into<Point>, font: &Handle<SkFont>, paint: &Handle<SkPaint> )

Draws glyphs at positions relative to origin styled with font and paint with supporting utf8 and cluster information.

This function draw glyphs at the given positions relative to the given origin. It does not perform typeface fallback for glyphs not found in the crate::Typeface in font.

The drawing obeys the current transform matrix and clipping.

All elements of paint: [crate::PathEffect], crate::MaskFilter, Shader, [crate::ColorFilter], and [ImageFilter]; apply to text. By default, draws filled black glyphs.

count number of glyphs to draw
glyphs the array of glyphIDs to draw
positions where to draw each glyph relative to origin
clusters array of size count of cluster information
utf8_text utf8text supporting information for the glyphs
origin the origin of all the positions
font typeface, text size and so, used to describe the text
paint blend, color, and so on, used to draw

pub fn draw_glyphs_at<'a>( &mut self, glyphs: &[u16], positions: impl Into<GlyphPositions<'a>>, origin: impl Into<Point>, font: &Handle<SkFont>, paint: &Handle<SkPaint> )

Draws count glyphs, at positions relative to origin styled with font and paint.

This function draw glyphs at the given positions relative to the given origin. It does not perform typeface fallback for glyphs not found in the crate::Typeface] in font.

The drawing obeys the current transform matrix and clipping.

All elements of paint: [crate::PathEffect], crate::MaskFilter, Shader, [crate::ColorFilter], and [ImageFilter]; apply to text. By default, draws filled black glyphs.

count number of glyphs to draw
glyphs the array of glyphIDs to draw
positions where to draw each glyph relative to origin, either a &[Point] or &[RSXform] slice
origin the origin of all the positions
font typeface, text size and so, used to describe the text
paint blend, color, and so on, used to draw

pub fn draw_text_blob( &mut self, blob: impl AsRef<RCHandle<SkTextBlob>>, origin: impl Into<Point>, paint: &Handle<SkPaint> ) -> &mut Canvas

Draws [TextBlob] blob at (origin.x, origin.y), using clip, Matrix, and Paint paint.

blob contains glyphs, their positions, and paint attributes specific to text: crate::Typeface, Paint text size, Paint text scale x, Paint text skew x, Paint align, Paint hinting, anti-alias, Paint fake bold, Paint font embedded bitmaps, Paint full hinting spacing, LCD text, Paint linear text, and Paint subpixel text.

[TextEncoding] must be set to [TextEncoding::GlyphId].

Elements of paint: [crate::PathEffect], crate::MaskFilter, Shader, [crate::ColorFilter], and [ImageFilter]; apply to blob.

blob glyphs, positions, and their paints’ text size, typeface, and so on
origin horizontal and vertical offset applied to blob
paint blend, color, stroking, and so on, used to draw

pub fn draw_picture( &mut self, picture: impl AsRef<RCHandle<SkPicture>>, matrix: Option<&Matrix>, paint: Option<&Handle<SkPaint>> ) -> &mut Canvas

Draws [Picture] picture, using clip and Matrix; transforming picture with Matrix matrix, if provided; and use Paint paint alpha, [crate::ColorFilter], [ImageFilter], and [BlendMode], if provided.

If paint is not None, then the picture is always drawn into a temporary layer before actually landing on the canvas. Note that drawing into a layer can also change its appearance if there are any non-associative blend modes inside any of the pictures elements.

picture recorded drawing commands to play
matrix Matrix to rotate, scale, translate, and so on; may be None
paint Paint to apply transparency, filtering, and so on; may be None

pub fn draw_vertices( &mut self, vertices: &RCHandle<SkVertices>, mode: SkBlendMode, paint: &Handle<SkPaint> ) -> &mut Canvas

Draws [Vertices] vertices, a triangle mesh, using clip and Matrix. If paint contains an Shader and vertices does not contain tex coords, the shader is mapped using the vertices’ positions.

[BlendMode] is ignored if [Vertices] does not have colors. Otherwise, it combines

the Shader if Paint contains [Shader
or the opaque Paint color if Paint does not contain Shader as the src of the blend and the interpolated vertex colors as the dst.

crate::MaskFilter, [crate::PathEffect], and antialiasing on Paint are ignored.

vertices triangle mesh to draw
mode combines vertices’ colors with Shader if present or Paint opaque color if not. Ignored if the vertices do not contain color.
paint specifies the Shader, used as [Vertices] texture, and [crate::ColorFilter].

example: https://fiddle.skia.org/c/@Canvas_drawVertices example: https://fiddle.skia.org/c/@Canvas_drawVertices_2

pub fn draw_patch<'a>( &mut self, cubics: &[Point; 12], colors: impl Into<Option<&'a [Color; 4]>>, tex_coords: Option<&[Point; 4]>, mode: SkBlendMode, paint: &Handle<SkPaint> ) -> &mut Canvas

Draws a Coons patch: the interpolation of four cubics with shared corners, associating a color, and optionally a texture Point, with each corner.

Point array cubics specifies four Path cubic starting at the top-left corner, in clockwise order, sharing every fourth point. The last Path cubic ends at the first point.

Color array color associates colors with corners in top-left, top-right, bottom-right, bottom-left order.

If paint contains Shader, Point array tex_coords maps Shader as texture to corners in top-left, top-right, bottom-right, bottom-left order. If tex_coords is None, Shader is mapped using positions (derived from cubics).

[BlendMode] is ignored if colors is None. Otherwise, it combines

the Shader if Paint contains Shader
or the opaque Paint color if Paint does not contain Shader as the src of the blend and the interpolated patch colors as the dst.

crate::MaskFilter, [crate::PathEffect], and antialiasing on Paint are ignored.

cubics Path cubic array, sharing common points
colors color array, one for each corner
tex_coords Point array of texture coordinates, mapping Shader to corners; may be None
mode combines patch’s colors with Shader if present or Paint opaque color if not. Ignored if colors is None.
paint Shader, [crate::ColorFilter], [BlendMode], used to draw

pub fn draw_drawable( &mut self, drawable: &mut RCHandle<SkDrawable>, matrix: Option<&Matrix> )

Draws [Drawable] drawable using clip and Matrix, concatenated with optional matrix.

If Canvas has an asynchronous implementation, as is the case when it is recording into [Picture], then drawable will be referenced, so that [RCHandle<Drawable>::draw()] can be called when the operation is finalized. To force immediate drawing, call [RCHandle<Drawable>::draw()] instead.

drawable custom struct encapsulating drawing commands
matrix transformation applied to drawing; may be None

example: https://fiddle.skia.org/c/@Canvas_drawDrawable

pub fn draw_drawable_at( &mut self, drawable: &mut RCHandle<SkDrawable>, offset: impl Into<Point> )

Draws [Drawable] drawable using clip and Matrix, offset by (offset.x, offset.y).

If Canvas has an asynchronous implementation, as is the case when it is recording into [Picture], then drawable will be referenced, so that [RCHandle<Drawable>::draw()] can be called when the operation is finalized. To force immediate drawing, call [RCHandle<Drawable>::draw()] instead.