Trait DrawBackend 

pub trait DrawBackend {
    // Required methods
    fn draw_circle(
        &mut self,
        center: (f64, f64),
        radius: f64,
        style: &PointStyle,
    ) -> Result<(), RenderError>;
    fn draw_line(
        &mut self,
        points: &[(f64, f64)],
        style: &LineStyle,
    ) -> Result<(), RenderError>;
    fn draw_rect(
        &mut self,
        top_left: (f64, f64),
        bottom_right: (f64, f64),
        style: &RectStyle,
    ) -> Result<(), RenderError>;
    fn draw_text(
        &mut self,
        text: &str,
        pos: (f64, f64),
        style: &TextStyle,
    ) -> Result<(), RenderError>;
    fn draw_polygon(
        &mut self,
        points: &[(f64, f64)],
        style: &RectStyle,
    ) -> Result<(), RenderError>;
    fn plot_area(&self) -> Rect;
    fn total_area(&self) -> Rect;

    // Provided methods
    fn draw_polygon_rings(
        &mut self,
        rings: &[Vec<(f64, f64)>],
        style: &RectStyle,
    ) -> Result<(), RenderError> { ... }
    fn draw_rect_pattern(
        &mut self,
        top_left: (f64, f64),
        bottom_right: (f64, f64),
        pattern: &FillPattern,
        style: &RectStyle,
    ) -> Result<(), RenderError> { ... }
    fn draw_polygon_pattern(
        &mut self,
        points: &[(f64, f64)],
        pattern: &FillPattern,
        style: &RectStyle,
    ) -> Result<(), RenderError> { ... }
    fn draw_polygon_rings_pattern(
        &mut self,
        rings: &[Vec<(f64, f64)>],
        pattern: &FillPattern,
        style: &RectStyle,
    ) -> Result<(), RenderError> { ... }
    fn draw_polygon_rings_precise(
        &mut self,
        rings: &[Vec<(f64, f64)>],
        pattern: Option<&FillPattern>,
        precision: Option<u8>,
        style: &RectStyle,
    ) -> Result<(), RenderError> { ... }
    fn draw_text_with_title(
        &mut self,
        text: &str,
        pos: (f64, f64),
        style: &TextStyle,
        _title: Option<&str>,
    ) -> Result<(), RenderError> { ... }
    fn draw_text_runs(
        &mut self,
        runs: &[(&str, Option<&str>)],
        pos: (f64, f64),
        style: &TextStyle,
    ) -> Result<(), RenderError> { ... }
    fn set_tooltip(&mut self, _tooltip: Option<String>) { ... }
    fn set_mark_axis(&mut self, _key: Option<String>) { ... }
    fn set_mark_series(&mut self, _series: Option<String>) { ... }
    fn set_mark_value(&mut self, _value: Option<String>) { ... }
    fn set_mark_geom(&mut self, _geom: Option<&str>) { ... }
    fn warn(&mut self, _message: String) { ... }
    fn set_mark_part(&mut self, _part: Option<&str>) { ... }
    fn set_mark_attrs(&mut self, _attrs: Vec<(String, String)>) { ... }
    fn wants_formatted_values(&self) -> bool { ... }
    fn set_mark_fvalue(&mut self, _value: Option<String>) { ... }
    fn set_mark_fx(&mut self, _value: Option<String>) { ... }
    fn set_mark_class(&mut self, _class: Option<String>) { ... }
    fn set_mark_group(&mut self, _group: Option<(String, String)>) { ... }
    fn set_layer_attrs(&mut self, _attrs: Vec<(String, String)>) { ... }
    fn draw_shape(
        &mut self,
        center: (f64, f64),
        radius: f64,
        style: &PointStyle,
    ) -> Result<(), RenderError> { ... }
    fn draw_quadratic(
        &mut self,
        p0: (f64, f64),
        ctrl: (f64, f64),
        p1: (f64, f64),
        style: &LineStyle,
    ) -> Result<(), RenderError> { ... }
}

Our rendering abstraction, independent of plotters details.

Required Methods

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

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

fn draw_rect( &mut self, top_left: (f64, f64), bottom_right: (f64, f64), style: &RectStyle, ) -> Result<(), RenderError>

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

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

fn plot_area(&self) -> Rect

fn total_area(&self) -> Rect

Provided Methods

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

Draw a polygon with holes: rings[0] is the exterior, every other ring a hole cut out of it under the even-odd fill rule (geom_sf’s Polygon, OGC/sf convention — see spatial::Geometry::Polygon). One stroke/stroke_width draws every ring’s outline, exterior and holes alike (as ggplot2’s geom_sf does).

Default: no real hole cut-out (for backends that pre-date this method) — the exterior ring filled and stroked, every other ring stroked only. Backends with a resolution-independent fill (SVG) or a scanline rasteriser (pixel/plotters) should override this to use their fill rule across every ring at once.

fn draw_rect_pattern( &mut self, top_left: (f64, f64), bottom_right: (f64, f64), pattern: &FillPattern, style: &RectStyle, ) -> Result<(), RenderError>

Like draw_rect, but filled with pattern instead of style.fill (geom_rect/geom_tile’s no-data cells, #206) — style.stroke/stroke_width/clip/corner_radius still apply, only the fill differs.

Default: flattens pattern to its FillPattern::bg and draws an ordinary draw_rect — the plotters backend has no pattern-fill primitive and keeps this default (“falls back to bg”). The native SVG backend overrides this to register a <defs><pattern> (deduped, this backend’s own id prefix) and fill with its url(#…) reference; the pixel/canvas backend overrides it to rasterise the actual stripes per pixel (“raster stripes”).

fn draw_polygon_pattern( &mut self, points: &[(f64, f64)], pattern: &FillPattern, style: &RectStyle, ) -> Result<(), RenderError>

Like draw_polygon, but filled with pattern instead of style.fill (#206). Default/override split: see draw_rect_pattern.

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

Like draw_polygon_rings, but filled with pattern instead of style.fill (geom_sf/geom_polygon’s no-data features, #206) — holes still cut out under the even-odd rule, exactly as a flat fill would. Default/override split: see draw_rect_pattern.

fn draw_polygon_rings_precise( &mut self, rings: &[Vec<(f64, f64)>], pattern: Option<&FillPattern>, precision: Option<u8>, style: &RectStyle, ) -> Result<(), RenderError>

Like draw_polygon_rings/ draw_polygon_rings_pattern, but lets the caller ask for a compact path encoding at a given decimal precision — relative commands after the first M instead of absolute L per point, geometrically identical within that precision (#214). geom_sf ties precision to its own simplify_px (more simplification tolerates coarser precision); every other caller of the two methods above is untouched, so their output doesn’t move.

Default: precision is ignored and this just dispatches to draw_polygon_rings/ draw_polygon_rings_pattern — correct (if not byte-compact) for every backend, including ones that pre-date this method. Only the native SVG backend, which actually writes path text, overrides it to shrink the encoding when precision is Some.

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

Like draw_text, but with an optional <title> tooltip carrying the full text when text itself has been shortened (e.g. a truncated-with-ellipsis legend label, #159). Default: ignores title and draws text plain — backends without native tooltip support (anything but SVG) have no better option. SVG overrides this to emit the <title> child, escaped the same way every other text run is.

fn draw_text_runs( &mut self, runs: &[(&str, Option<&str>)], pos: (f64, f64), style: &TextStyle, ) -> Result<(), RenderError>

Draw one line as consecutive runs, each optionally an http(s) hyperlink (ggspatial-style attribution: “© BKG” linked, a licence code linked, plain connective text between them — annotation_attribution’s .link()/.runs(), #196). pos/style place and style the line as a whole, same as draw_text — style.anchor aligns the total run sequence, not each run.

Default: concatenates the runs’ text and draws it plain with draw_text, dropping every link — the sensible fallback for a backend with no link primitive (pixel/canvas, plotters). The native SVG backend overrides this to wrap each linked run in <a href="…" target="_blank" rel="noopener"> with an underline, inside one <text> element so the anchor still aligns the whole line.

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 set_mark_class(&mut self, _class: Option<String>)

Extra CSS class tokens for subsequently-drawn marks (#221’s Aes::class), space-separated and already validated by the caller; None clears them, per row. The SVG backend appends them to the mark’s own class="gg-mark gg-<kind>" (re-validating every token as defence in depth). Default: no-op.

fn set_mark_group(&mut self, _group: Option<(String, String)>)

Put subsequently-drawn marks into the caller-named group (attribute name, value) — e.g. ("data-of", "node-7") — until cleared with None (#221’s Aes::group_wrap). The SVG backend collects every mark with the same pair into one <g name="value">, placed where the group’s first mark was drawn. Default: no-op (a raster backend has no grouping).

fn set_layer_attrs(&mut self, _attrs: Vec<(String, String)>)

Per-layer SVG attributes for every mark the current layer draws (#221’s GGPlot::layer_svg_attr): class tokens, aria-hidden, pointer-events, data-*, already validated by the caller. An empty Vec clears them (set before a layer draws, cleared after). Default: no-op.

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

Draw a point with a specific shape. Default delegates to draw_circle for Circle.

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

Draw a quadratic Bézier curve from p0 to p1 with control point ctrl, in pixel space. The default implementation flattens the curve to 32 line segments and draws it with draw_line; backends that support real curves (SVG) should override this. Non-finite input draws nothing.

Dyn Compatibility

This trait is dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety".

Implementors

impl DrawBackend for SvgBackend

impl<'a, DB: DrawingBackend> DrawBackend for PlottersAdapter<'a, DB>