Struct GlyphPainter 

pub(crate) struct GlyphPainter<'a> {
    pub(crate) font: &'a FontRef<'a>,
    pub(crate) location: LocationRef<'a>,
    pub(crate) svg: &'a mut XmlWriter,
    pub(crate) path_buf: &'a mut String,
    pub(crate) gradient_index: usize,
    pub(crate) clip_path_index: usize,
    pub(crate) foreground_color: Color,
    pub(crate) transform: Transform,
    pub(crate) outline_transform: Transform,
    pub(crate) transforms_stack: Vec<Transform>,
    pub(crate) clip_stack: Vec<Option<Rect>>,
}

Fields

font: &'a FontRef<'a>

location: LocationRef<'a>

The variation location to draw outlines at.

svg: &'a mut XmlWriter

path_buf: &'a mut String

gradient_index: usize

clip_path_index: usize

foreground_color: Color

transform: Transform

outline_transform: Transform

transforms_stack: Vec<Transform>

clip_stack: Vec<Option<Rect>>

The bounding box of every active clip, in the root coordinate space. None means the clip is empty (or its bounds are unknown).

Implementations

impl<'a> GlyphPainter<'a>

fn write_gradient_stops(&mut self, stops: &[ColorStop])

fn paint_solid(&mut self, color: Color)

fn paint_linear_gradient( &mut self, p0: Point<f32>, p1: Point<f32>, color_stops: &[ColorStop], extend: Extend, )

fn paint_radial_gradient( &mut self, c0: Point<f32>, r0: f32, c1: Point<f32>, r1: f32, color_stops: &[ColorStop], extend: Extend, )

fn paint_sweep_gradient( &mut self, _c0: Point<f32>, _start_angle: f32, _end_angle: f32, _color_stops: &[ColorStop], _extend: Extend, )

impl GlyphPainter<'_>

fn clip_with_path(&mut self, path: &str)

fn outline_glyph(&mut self, glyph_id: GlyphId) -> Option<Rect>

Outlines a glyph into path_buf at the current variation location (an empty path on failure), records the current transform as the outline transform and returns the outline’s conservative bounding box in the glyph’s local coordinate space.

fn paint_brush(&mut self, brush: Brush<'_>)

Paints path_buf (positioned by the outline transform) with the given brush.

fn palette_index_to_color(&self, palette_index: u16, alpha: f32) -> Color

Trait Implementations

impl<'a> ColorPainter for GlyphPainter<'a>

fn push_transform(&mut self, transform: Transform)

Push the specified transform by concatenating it to the current transformation matrix.

fn pop_transform(&mut self)

Restore the transformation matrix to the state before the previous push_transform call.

fn fill_glyph( &mut self, glyph_id: GlyphId, brush_transform: Option<Transform>, brush: Brush<'_>, )

Combined clip and fill operation.

fn push_clip_glyph(&mut self, glyph_id: GlyphId)

Apply a clip path in the shape of glyph specified by glyph_id.

fn push_clip_box(&mut self, clip_box: BoundingBox<f32>)

Apply a clip rectangle specified by clip_rect.

fn pop_clip(&mut self)

Restore the clip state to the state before a previous push_clip_glyph or push_clip_box call.

fn fill(&mut self, brush: Brush<'_>)

Fill the current clip area with the specified gradient fill.

fn push_layer(&mut self, composite_mode: CompositeMode)

Open a new layer, and merge the layer down using composite_mode when pop_layer is called, signalling that this layer is done drawing.

fn pop_layer(&mut self)

Merge the pushed layer down using composite_mode passed to the matching push_layer.

fn paint_cached_color_glyph( &mut self, _glyph: GlyphId, ) -> Result<PaintCachedColorGlyph, PaintError>

Optionally implement this method: Draw an unscaled COLRv1 glyph given the current transformation matrix (as accumulated by push_transform calls).

fn pop_layer_with_mode(&mut self, _composite_mode: CompositeMode)

Alternative version of push_layer where the composite_mode is also passed to the method. This is useful for graphics libraries that need the compositing mode at layer pop time and do not want to manually track the mode.