Struct SvgRenderer 

pub struct SvgRenderer<L: TextLayout> {
    palette: Palette,
    outlines: Outlines,
    shaper: Shaper,
    layout: L,
    doc: RefCell<Document>,
    bounds: Bounds,
    warned: Cell<bool>,
}

Fields

palette: Palette

outlines: Outlines

The ink of the typeface layout measures in.

shaper: Shaper

The identity a layout that reports characters only cannot give.

layout: L

The host’s text engine — the one the canvas draws through.

doc: RefCell<Document>

The document under construction; draw calls append nodes to it.

bounds: Bounds

Running world-space bounding box of everything drawn so far.

warned: Cell<bool>

One Identity::ByChar warning per export, not per run.

Implementations

impl<L: TextLayout> SvgRenderer<L>

pub fn new(palette: Palette, layout: L) -> Self

The outlines are traced from the typeface layout lays text out in, so the glyphs written are the glyphs the canvas placed.

Panics

If that typeface’s embedded bytes are not a font this can read.

fn color(&self, swatch: impl Into<Swatch>) -> Color

Resolve a Swatch to a concrete color through the palette.

fn resolve_stroke(&self, stroke: impl Into<PaletteStroke>) -> Ink

Resolve a palette-based stroke to the width and color the SVG states.

pub fn finish(self) -> (String, Rect)

Finalize the <svg> root: set its viewBox/size to frame the content (with a small margin) and serialize it, with the viewBox rect — the exact world-space region the SVG depicts, for callers that place the output back into world coordinates (the PDF export’s page fit).

fn append(&self, node: impl Into<Box<dyn Node>>)

fn draw_glyphs( &self, pos: Pos2, anchor: Align2, laid: &Layout, font: &Font, color: Color, angle: Angle, ) -> Rect

Append each glyph of laid, anchored at world pos, as a filled <path>. When angle is non-zero the run is wrapped in a rotate(...) group about pos, matching the canvas’s rotated-text behaviour. Returns the unrotated anchored bounding rect.

fn identify(&self, run: &[Placed<'_>]) -> Vec<Option<GlyphId>>

Which outline each glyph of run draws, in order; None draws nothing.

An engine that reports the glyph it chose has answered this already. One that records the character behind each glyph has not: fi in a font with liga arrives as a ligature filed under 'f' plus a continuation glyph for 'i' — and outlining that 'i' by cmap stacks it on the next character. Re-shaping recovers the identity the layout dropped; the positions stay the layout’s.

Trait Implementations

impl<L: TextLayout> Renderer for SvgRenderer<L>

fn rect( &self, rect: Rect, rounding: WorldPx, fill: impl Into<Swatch>, stroke: impl Into<PaletteStroke>, )

fn line_segment(&self, points: [Pos2; 2], stroke: impl Into<PaletteStroke>)

fn line(&self, points: Vec<Pos2>, stroke: impl Into<PaletteStroke>)

fn circle( &self, center: Pos2, radius: WorldPx, fill: impl Into<Swatch>, stroke: impl Into<PaletteStroke>, )

fn add_convex_polygon( &self, points: Vec<Pos2>, fill: impl Into<Swatch>, stroke: impl Into<PaletteStroke>, )

fn text( &self, pos: Pos2, anchor: Align2, text: impl ToString, font: &Font, color: impl Into<Swatch>, ) -> Rect

fn rotated_text( &self, pos: Pos2, anchor: Align2, text: impl ToString, font: &Font, color: impl Into<Swatch>, angle: Angle, )

fn text_wrapped( &self, pos: Pos2, anchor: Align2, text: impl ToString, font: &Font, color: impl Into<Swatch>, max_width: WorldPx, ) -> Rect

Like Renderer::text but wraps to max_width (word wrap); WorldPx::UNBOUNDED draws unwrapped. The default ignores max_width and draws unwrapped; backends that lay text out override it. Both the on-screen and the SVG backend break the text with the same layout engine, so they agree on the break points.

fn text_size(&self, text: impl ToString, font: &Font) -> Vec2

fn text_size_wrapped( &self, text: impl ToString, font: &Font, max_width: WorldPx, ) -> Vec2

Like Renderer::text_size but measured with word wrap at max_width. The default ignores max_width.

fn text_layout(&self, text: &str, font: &Font, max_width: WorldPx) -> Layout

text laid out in font and word-wrapped at max_width, in world units: the rows Self::text_size_wrapped measures.

fn draw_image(&self, rect: Rect, image: &Asset)

Draw image (an SVG or PNG payload) filling the world-space rect. The caller sizes rect to honor the image’s aspect ratio (see Renderer::image_intrinsic_size), so each backend simply fills rect: the on-screen painter caches the bytes in its own hash → handle table and polls the toolkit’s loader, while the SVG exporter embeds the bytes as a base64 data URI.

fn image_intrinsic_size(&self, image: &Asset) -> Option<Vec2>

The intrinsic point size of image (always strictly positive), used by the caller for aspect-fit and the resize-ring geometry. None if the bytes are not a valid SVG/PNG.

fn animator(&self) -> Option<&dyn Animator>

The frame animation this backend drives, for interactive overlays drawn on the generic render path. The on-screen canvas supplies itself; offline backends (the SVG exporter) return None, so those overlays fall back to a static draw.

fn visible_world_bounds(&self) -> Option<Rect>

The world-space rect currently visible on screen, if this backend paints into a bounded viewport. The render path uses it to viewport-cull the scene: shapes outside it are skipped. None (the default) means “no viewport — draw everything”, which is what offline backends (the SVG exporter) want, so an export is never culled.