Struct Canvas 

pub struct Canvas<'a> { /* private fields */ }

A clipped, writable pixel target.

Every operation is clipped to Canvas::clip, which starts as the whole frame and only ever shrinks. Clipping is rectangular: that covers scrolling regions, damage-restricted repaint and nested panels, which is all a UI actually needs. Arbitrary clip shapes are not planned.

Coordinates are physical pixels relative to the frame origin, never relative to the clip.

Implementations

impl<'a> Canvas<'a>

pub fn new(frame: &'a mut Frame<'_>) -> Self

Borrows a frame for drawing, clipped to the whole frame.

pub fn from_pixels( pixels: &'a mut [u32], size: Size, stride: u32, format: PixelFormat, ) -> Option<Self>

Wraps a raw pixel slice. Returns None if it is too small for the geometry.

Prefer Canvas::new; this exists for offscreen buffers and benchmarks that have no Frame to hand.

pub const fn size(&self) -> Size

Full extent of the underlying frame.

pub const fn format(&self) -> PixelFormat

Word layout of the target.

pub const fn clip(&self) -> Rect

The region operations are currently restricted to.

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

Narrows the clip in place. Never widens it.

pub fn with_clip(&mut self, rect: Rect) -> Canvas<'_>

A canvas over the same pixels with a tighter clip.

The borrow ends when the returned canvas is dropped, so this is how a parent hands a child a region to draw in without either being able to escape it.

pub const fn is_clipped_out(&self) -> bool

Returns true if the clip admits no pixels, so drawing can be skipped.

pub fn visible(&self, rect: Rect) -> Option<Rect>

The clipped, visible part of rect.

pub fn clear(&mut self, color: Color)

Fills the entire clip with an opaque colour.

This is the full-frame clear when the clip is untouched, and the damage-restricted clear when it is not.

pub fn copy_from(&mut self, src: &PixelView<'_>, regions: &[Rect])

Copies matching regions out of another buffer.

Source and destination coordinates are the same, so this is the damage-driven “publish what changed” blit a double-buffered backend needs — not a general blitter. Regions are clipped to both buffers.

impl Canvas<'_>

pub fn blit_mask(&mut self, at: Point, mask: &Mask<'_>, color: impl Into<Paint>)

Composites mask in color, with its top-left corner at at.

Coverage multiplies the paint’s own alpha, so a half-transparent colour through a half-covered pixel lands at a quarter, which is what it should be.

impl Canvas<'_>

pub fn draw_glyph( &mut self, glyph: &Glyph, at: Point, scale: i32, color: impl Into<Paint>, )

Draws one glyph with its cell’s top-left corner at at.

pub fn draw_text( &mut self, font: &BitmapFont, at: Point, scale: i32, text: &str, color: impl Into<Paint>, ) -> Size

Draws text with the first cell’s top-left corner at at, honouring \n.

Returns the extent actually laid out, whether or not it was clipped.

impl Canvas<'_>

pub fn draw_line(&mut self, a: Point, b: Point, color: impl Into<Paint>)

Draws a one-pixel line between two pixel centres, anti-aliased.

Axis-aligned lines take an exact integer path and get no anti-aliasing, because a horizontal rule that has been softened to 97% grey looks like a rendering bug, not like quality. Everything else is a Wu-style two-pixel blend along the minor axis.

Thickness is not a parameter. Borders come from Canvas::stroke_rect and Canvas::stroke_rounded_rect; thick arbitrary-angle lines are not something a UI toolkit needs before it can draw a chart, and that is not this milestone.

impl Canvas<'_>

pub fn fill_rect(&mut self, rect: Rect, color: impl Into<Paint>)

Fills rect, compositing with the destination if the paint has alpha.

pub fn fill_rects(&mut self, rects: &[Rect], color: impl Into<Paint>)

Fills every rectangle. Overlapping rectangles composite twice.

pub fn stroke_rect( &mut self, rect: Rect, thickness: i32, color: impl Into<Paint>, )

Draws a border of thickness pixels inside rect.

The four bands are cut so they do not overlap. Drawing them as four full-length rectangles would composite the corners twice, which is invisible at full alpha and obvious at anything less.

impl Canvas<'_>

pub fn fill_rounded_rect( &mut self, rect: Rect, radius: i32, color: impl Into<Paint>, )

Fills a rectangle with rounded corners, anti-aliased.

radius is clamped to half the shorter side; a radius of zero is exactly Canvas::fill_rect.

pub fn stroke_rounded_rect( &mut self, rect: Rect, radius: i32, thickness: i32, color: impl Into<Paint>, )

Draws a rounded border of thickness pixels inside rect, anti-aliased.

The inner radius follows the outer one so the band keeps a constant width around the corner.

Trait Implementations

impl<'a> Debug for Canvas<'a>

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

Formats the value using the given formatter.