Struct SvgBackend 

pub struct SvgBackend { /* private fields */ }

Accumulates SVG markup for a plot rendered via DrawBackend.

Every number written to an attribute is finite: marks whose geometry is NaN/±inf are dropped (a polyline keeps its finite vertices), and non-finite style values fall back to safe defaults. All data-derived attribute values and text go through [escape].

Implementations

impl SvgBackend

pub fn new(width: u32, height: u32, plot_area: Rect) -> Self

pub fn set_root_attrs(&mut self, attrs: Vec<(String, String)>)

Add extra attributes to the root <svg> element (e.g. the data-domain family from root_data_attrs). Names must be plain attribute names; values are escaped on output.

pub fn extend_root_attrs(&mut self, attrs: Vec<(String, String)>)

Append extra attributes to the root <svg> element, after any already set by set_root_attrs (e.g. the data-domain family from root_data_attrs). Unlike set_root_attrs, this does not replace what is already there. Callers (GGPlot::svg_attr/PlotGrid::svg_attr, via [validate_root_attrs]) are responsible for name validation and collision checks; this just appends. Values are escaped on output.

pub fn take_warnings(&mut self) -> Vec<String>

Take the warnings reported while drawing (see DrawBackend::warn).

pub fn finish(self) -> String

Wrap the accumulated elements in a complete <svg> document. The data-plot attribute records the panel (data) area in viewBox units so a host can map screen coordinates back to data (e.g. for zoom/crosshair).

pub fn finish_fragment(self, x: f64, y: f64) -> String

Wrap the accumulated elements in a nested <svg> positioned at (x, y) in a parent SVG’s user space — no xmlns (it inherits the parent’s namespace), so the result can be pasted into a larger SVG as-is. data-plot stays in this fragment’s own viewBox units.

Trait Implementations

impl DrawBackend for SvgBackend

fn draw_shape( &mut self, (cx, cy): (f64, f64), radius: f64, style: &PointStyle, ) -> Result<(), RenderError>

Native shapes: filled polygons for square/triangle/diamond, a single stroked <path> for the + / × glyphs (so each point stays one hoverable mark carrying its data-* attributes).

fn draw_quadratic( &mut self, p0: (f64, f64), ctrl: (f64, f64), p1: (f64, f64), style: &LineStyle, ) -> Result<(), RenderError>

Emit a native <path d="M.. Q.."> quadratic Bézier (one real curve instead of a flattened polyline). Non-finite input draws nothing.

fn draw_polygon_rings( &mut self, rings: &[Vec<(f64, f64)>], style: &RectStyle, ) -> Result<(), RenderError>

One <path>, every ring a subpath (M…Z), fill-rule="evenodd" so holes (rings after the first) are cut out of the fill — SVG’s native equivalent of the even-odd rasteriser the pixel/plotters backends run (#178). A ring with fewer than 3 finite points is dropped; the whole shape draws nothing when every ring is.

fn draw_text_with_title( &mut self, text: &str, (x, y): (f64, f64), style: &TextStyle, title: Option<&str>, ) -> Result<(), RenderError>

#159: with title, wraps the <text> in a <title> child carrying the full (escaped) label — e.g. a legend key truncated with an ellipsis to fit a vertical multi-column grid.

fn plot_area(&self) -> Rect

fn total_area(&self) -> Rect

fn set_tooltip(&mut self, tooltip: Option<String>)

Attach a tooltip to subsequently-drawn marks until cleared with None. Backends that produce interactive output (SVG) emit it as a <title> for a native hover tooltip; others ignore it. Default: no-op.

fn set_mark_axis(&mut self, key: Option<String>)

Attach an axis (x) key to subsequently-drawn marks — SVG emits it as a data-x attribute so a host can group marks by x (axis-pointer tooltip). Default: no-op.

fn set_mark_series(&mut self, series: Option<String>)

Attach a series key (the colour / fill / group level) to subsequently drawn marks — SVG emits it as data-series, so a host can highlight or filter one series without parsing the tooltip. Default: no-op.

fn set_mark_value(&mut self, value: Option<String>)

Attach the raw measured value (the unformatted y) to subsequently drawn marks — SVG emits it as data-value. Default: no-op.

fn set_mark_geom(&mut self, geom: Option<&str>)

Tag subsequently drawn elements as data marks of the named geom (the layer’s Geom::name) until cleared with None. SVG emits class="gg-mark gg-<kind>" (kind from the primitive: point, line, band, bar, text) plus data-geom, so a host can select data marks without matching axes, grid lines or legends. Default: no-op.

fn warn(&mut self, message: String)

Report a non-fatal problem found while drawing (e.g. labels a repel layout had to drop). Backends that collect warnings (the native SVG backend) append it to the render warnings. Default: ignored.

fn set_mark_part(&mut self, part: Option<&str>)

Mark subsequently-drawn marks as belonging to a sub-part of a larger geom (e.g. "arrow" for an arrowhead drawn alongside a segment/curve/ path/line). While set, the SVG backend writes data-part="<part>" aria-hidden="true" and omits the <title> tooltip (the part is decorative; the parent mark already carries the semantic info). data-x/data-series/data-value (and any user data-* attrs) are still written. Default: no-op.

fn set_mark_attrs(&mut self, attrs: Vec<(String, String)>)

Attach arbitrary data-* attributes to subsequently-drawn marks (B1-7’s Aes::data_attr). The SVG backend writes each, escaped; an attr with the same name as a built-in (data-x, data-series, data-value) replaces it rather than duplicating it. An empty Vec clears any previously set attrs. Default: no-op.

fn wants_formatted_values(&self) -> bool

Whether the caller asked for per-mark formatted values (crate::plot::GGPlot::svg_formatted_values, B2-4) — a query a geom checks before doing the (otherwise pointless) work of resolving a scale’s formatter for set_mark_fvalue/set_mark_fx. Default false, so the feature is byte-identical when never turned on.

fn set_mark_fvalue(&mut self, value: Option<String>)

data-fvalue on subsequently-drawn marks: the “value” aesthetic’s raw data value (y for most geoms, fill for hex/tile), formatted through that aesthetic’s scale (Scale::format_value) — e.g. a de-DE currency string. Only meaningful while wants_formatted_values is true; None clears any previous mark’s value, per row. Default: no-op.

fn set_mark_fx(&mut self, value: Option<String>)

data-fx on subsequently-drawn marks: the x value formatted through the x scale (e.g. a datetime axis’s ISO/locale date). The SVG backend omits it when it matches the already-written data-x, so a plain numeric x doesn’t get a redundant duplicate attribute. Default: no-op.

fn draw_circle( &mut self, (cx, cy): (f64, f64), radius: f64, style: &PointStyle, ) -> Result<(), RenderError>

fn draw_line( &mut self, pts: &[(f64, f64)], style: &LineStyle, ) -> Result<(), RenderError>

fn draw_rect( &mut self, (x0, y0): (f64, f64), (x1, y1): (f64, f64), style: &RectStyle, ) -> Result<(), RenderError>

fn draw_polygon( &mut self, pts: &[(f64, f64)], style: &RectStyle, ) -> Result<(), RenderError>

fn draw_text( &mut self, text: &str, pos: (f64, f64), style: &TextStyle, ) -> Result<(), RenderError>