Struct DrawContext 

pub struct DrawContext { /* private fields */ }

Immediate-mode drawing context used by canvas(size, draw).

Implementations

impl DrawContext

pub fn bounds(&self) -> Bounds<Pixels>

Returns the canvas-local bounds for the current draw pass.

pub fn size(&self) -> Size<Pixels>

Returns the canvas-local size for the current draw pass.

pub fn command_count(&self) -> usize

Number of queued draw commands that have not been flushed to the window.

pub fn is_empty(&self) -> bool

Whether there are no queued draw commands.

pub fn reserve_commands(&mut self, additional: usize)

Reserve command storage for a known batch size.

Real-time canvases should call this before emitting large, similarly sized batches to avoid growing the command buffer during a frame.

pub fn path_count(&self) -> usize

Number of queued path commands.

pub fn quad_count(&self) -> usize

Number of queued quad commands.

pub fn filled_quad_count(&self) -> usize

Number of queued filled quad commands.

pub fn stroked_quad_count(&self) -> usize

Number of queued stroked quad commands.

pub fn text_count(&self) -> usize

Number of queued text commands.

pub fn image_count(&self) -> usize

Number of queued image commands.

pub fn state_stack_depth(&self) -> usize

Number of saved drawing states waiting to be restored.

pub fn to_text(&self) -> String

Content-safe summary of queued canvas drawing work.

pub fn fill_path(&mut self, path: &Path<Pixels>, fill: impl Into<Background>)

Fill an existing path with the given background.

pub fn stroke_path(&mut self, path: &Path<Pixels>, stroke: Stroke)

Stroke a path using the retained source outline stored on the path.

pub fn stroke_line( &mut self, from: Point<Pixels>, to: Point<Pixels>, stroke: Stroke, )

Stroke a straight line segment between two points.

pub fn fill_rect(&mut self, bounds: Bounds<Pixels>, fill: impl Into<Background>)

Fill an axis-aligned rectangle.

pub fn fill_rects( &mut self, rects: impl IntoIterator<Item = (Bounds<Pixels>, Background)>, )

Queue a batch of axis-aligned rectangles with one command-buffer reservation.

pub fn fill_rounded_rect( &mut self, bounds: Bounds<Pixels>, radii: impl Into<Corners<Pixels>>, fill: impl Into<Background>, )

Fill a rounded rectangle.

pub fn stroke_rect(&mut self, bounds: Bounds<Pixels>, stroke: Stroke)

Stroke the outline of an axis-aligned rectangle (web canvas strokeRect).

pub fn stroke_rounded_rect( &mut self, bounds: Bounds<Pixels>, radii: impl Into<Corners<Pixels>>, stroke: Stroke, )

Stroke the outline of a rounded rectangle.

pub fn fill_circle( &mut self, center: Point<Pixels>, radius: Pixels, fill: impl Into<Background>, )

Fill a circle.

pub fn fill_circles( &mut self, circles: impl IntoIterator<Item = (Point<Pixels>, Pixels, Background)>, )

Queue a batch of filled circles through the renderer’s rounded-quad fast path.

pub fn stroke_circle( &mut self, center: Point<Pixels>, radius: Pixels, stroke: Stroke, )

Stroke a circle.

pub fn fill_ellipse( &mut self, center: Point<Pixels>, radius_x: Pixels, radius_y: Pixels, fill: impl Into<Background>, )

Fill an ellipse centered at center with the given horizontal and vertical radii.

pub fn stroke_ellipse( &mut self, center: Point<Pixels>, radius_x: Pixels, radius_y: Pixels, stroke: Stroke, )

Stroke an ellipse centered at center with the given horizontal and vertical radii.

pub fn with_transform<R>( &mut self, matrix: TransformationMatrix, f: impl FnOnce(&mut Self) -> R, ) -> R

Apply an affine transform to commands issued within the callback.

pub fn with_opacity<R>( &mut self, opacity: f32, f: impl FnOnce(&mut Self) -> R, ) -> R

Multiply the current drawing opacity for commands issued within the callback.

pub fn with_clip<R>( &mut self, bounds: Bounds<Pixels>, f: impl FnOnce(&mut Self) -> R, ) -> R

Restrict drawing to an additional clip rectangle.

pub fn save(&mut self)

Save the current drawing state (transform, opacity, clip) onto the state stack.

Mirrors CanvasRenderingContext2D.save(). Pair every save with a matching DrawContext::restore. This is the flat alternative to the scoped DrawContext::with_transform / DrawContext::with_opacity / DrawContext::with_clip helpers, for loops and recursion where closures are awkward.

pub fn restore(&mut self)

Restore the most recently saved drawing state. No-op if the stack is empty.

Mirrors CanvasRenderingContext2D.restore().

pub fn translate(&mut self, x: Pixels, y: Pixels)

Translate the current transform by the given offset, in canvas-local pixels.

pub fn rotate(&mut self, radians: f32)

Rotate the current transform clockwise by the given angle in radians.

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

Scale the current transform by independent x and y factors.

pub fn set_global_alpha(&mut self, alpha: f32)

Set the global drawing opacity applied to subsequent commands (clamped to 0.0..=1.0).

Mirrors CanvasRenderingContext2D.globalAlpha. Saved and restored by DrawContext::save / DrawContext::restore.

pub fn clip_rect(&mut self, bounds: Bounds<Pixels>)

Restrict subsequent drawing to the given rectangle, intersected with any existing clip. The flat counterpart to DrawContext::with_clip.

pub fn draw_text( &mut self, text: &ShapedLine, origin: Point<Pixels>, color: Hsla, )

Draw a shaped line of text at the given local origin.

pub fn draw_text_aligned( &mut self, text: &ShapedLine, origin: Point<Pixels>, color: Hsla, align: TextAlign, )

Draw a shaped line of text anchored horizontally at origin per align, mirroring the web canvas textAlign (origin.x is the left/center/right anchor).

pub fn draw_image(&mut self, image: Arc<RenderImage>, bounds: Bounds<Pixels>)

Draw an image filling the given rectangle, respecting the current transform, clip, and opacity. Mirrors CanvasRenderingContext2D.drawImage.

pub fn draw_image_rounded( &mut self, image: Arc<RenderImage>, bounds: Bounds<Pixels>, corner_radii: impl Into<Corners<Pixels>>, )

Draw an image filling the given rectangle with rounded corners.

pub fn draw_image_frame( &mut self, image: Arc<RenderImage>, bounds: Bounds<Pixels>, frame_index: usize, grayscale: bool, )

Draw a single frame of a multi-frame image (e.g. an animated GIF), optionally desaturated.

pub fn flush(&mut self, window: &mut Window, _cx: &mut App)

Flush any queued draw commands into the window.

Call this when mixing DrawContext drawing with direct Window painting and you need exact interleaving order.