Struct Canvas 

pub struct Canvas { /* private fields */ }

An imperative painter producing content-stream operators.

Implementations

impl Canvas

pub fn new() -> Canvas

Creates an empty canvas.

pub fn save(&mut self)

Pushes the graphics state (q).

pub fn restore(&mut self)

Pops the graphics state (Q).

pub fn transform(&mut self, m: Matrix)

Concatenates m onto the current transformation matrix (cm).

pub fn set_line_width(&mut self, width: f32)

Sets the stroke line width (w).

pub fn set_line_cap(&mut self, cap: LineCap)

Sets the line cap style (J).

pub fn set_line_join(&mut self, join: LineJoin)

Sets the line join style (j).

pub fn set_miter_limit(&mut self, limit: f32)

Sets the miter limit (M).

pub fn set_dash(&mut self, pattern: &[f32], phase: f32)

Sets the dash pattern (d).

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

Sets the fill color (g/rg/k).

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

Sets the stroke color (G/RG/K).

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

Begins a new subpath at (x, y) (m).

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

Straight segment to (x, y) (l).

pub fn curve_to(&mut self, x1: f32, y1: f32, x2: f32, y2: f32, x3: f32, y3: f32)

Cubic Bézier with two control points (c).

pub fn close(&mut self)

Closes the current subpath (h).

pub fn rect(&mut self, x: f32, y: f32, width: f32, height: f32)

Appends a rectangle subpath (re).

pub fn circle(&mut self, cx: f32, cy: f32, r: f32)

Appends a circle as four Bézier arcs, starting at the rightmost point (cx + r, cy) and running counter-clockwise.

pub fn ellipse(&mut self, cx: f32, cy: f32, rx: f32, ry: f32)

Appends an axis-aligned ellipse as four Bézier arcs, starting at the rightmost point (cx + rx, cy) and running counter-clockwise.

pub fn polygon(&mut self, points: &[Point])

Appends a closed polygon through points. Fewer than three points appends nothing.

pub fn fill(&mut self)

Fills the current path, nonzero winding (f).

pub fn fill_even_odd(&mut self)

Fills the current path, even-odd (f*).

pub fn stroke(&mut self)

Strokes the current path (S).

pub fn close_stroke(&mut self)

Closes and strokes the current path (s).

pub fn fill_stroke(&mut self)

Fills then strokes the current path (B).

pub fn clip(&mut self)

Intersects the clip with the current path, nonzero (W n). The path is consumed: it is ended without painting and a fresh path starts afterwards.

pub fn clip_even_odd(&mut self)

Intersects the clip with the current path, even-odd (W* n). The path is consumed: it is ended without painting and a fresh path starts afterwards.

pub fn end_path(&mut self)

Ends the current path without painting (n).

pub fn text( &mut self, text: &str, x: f32, y: f32, font: Standard14, size: f32, ) -> Result<()>

Shows one line of text with its baseline origin at (x, y) (BT/Tf/Td/Tj/ET). Errors on unencodable characters before any operator is pushed, leaving the canvas untouched.

pub fn add_image(&mut self, image: ImageData) -> ImageHandle

Registers an image for use with draw_image.

pub fn draw_image( &mut self, image: ImageHandle, x: f32, y: f32, width: f32, height: f32, )

Paints a registered image into the axis-aligned box at (x, y) with the given size (q cm Do Q).

pub fn group(&mut self, canvas: Canvas, bbox: [f32; 4]) -> GroupHandle

Registers a finished sub-canvas as a form group, with bbox ([llx, lly, urx, ury]) becoming the form’s /BBox. Paint it with draw_group.

pub fn draw_group(&mut self, group: GroupHandle, matrix: Matrix)

Paints a registered group under matrix (q cm /GpN Do Q). Two calls with the same group reference the same form resource.

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

Sets the nonstroking alpha constant (gs referencing /ca).

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

Sets the stroking alpha constant (gs referencing /CA).

pub fn set_blend_mode(&mut self, mode: BlendMode)

Sets the blend mode (gs referencing /BM).

pub fn op(&mut self, op: Op)

Pushes a raw operator — the escape hatch for anything the methods above don’t cover. Resource-referencing operators are the caller’s responsibility to keep consistent with the naming contract.

pub fn ops(&self) -> &[Op]

The operators accumulated so far, in paint order.

Trait Implementations

impl Debug for Canvas

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

Formats the value using the given formatter.

impl Default for Canvas

fn default() -> Canvas

Returns the “default value” for a type.