@@ -0,0 +1,892 @@
1+// Surface/path/paint/readback patterns adapted from fframes at
2+// 4ffb052d3430e0672b4f3647450c181606ddf418. See ../licenses/fframes.txt.
3+use std::collections::HashMap;
4+use std::str::FromStr;
5+use std::sync::Arc;
6+
7+use fontdb::{Database, Family, Query, Source, Stretch, Style, Weight, ID};
8+use rustybuzz::{Face, Feature, UnicodeBuffer};
9+use skia_safe::canvas::SaveLayerRec;
10+use skia_safe::{
11+ color_filters, image_filters, paint, surfaces, AlphaType, BlendMode, Canvas, ClipOp, ColorType,
12+ Data, FilterMode, Font, FontHinting, FontMgr, ImageInfo, Matrix, Paint, PaintStyle, Path,
13+ PathBuilder, PathFillType, PictureRecorder, Point, Rect, Surface, TileMode, Typeface,
14+};
15+use unicode_script::{Script, UnicodeScript};
16+use unicode_segmentation::UnicodeSegmentation;
17+
18+use crate::{failure, FontAsset, HostResult};
19+
20+#[derive(Default)]
21+pub(crate) struct Metrics {
22+ pub width: f64,
23+ pub ascent: f64,
24+ pub descent: f64,
25+}
26+
27+pub(crate) type Color = [u8; 4];
28+
29+pub(crate) struct Stroke {
30+ pub color: Color,
31+ pub width: f32,
32+ pub join: i32,
33+ pub cap: i32,
34+}
35+
36+pub(crate) struct CirclePattern {
37+ pub rect: [f32; 4],
38+ pub background: Color,
39+ pub ink: Color,
40+ pub tile: f32,
41+ pub radius: f32,
42+ pub origin: [f32; 2],
43+}
44+#[derive(Clone)]
45+struct DrawStyle {
46+ blend: BlendMode,
47+ blur: f32,
48+ tint: Option<skia_safe::ColorFilter>,
49+}
50+
51+struct Raster {
52+ surface: Surface,
53+ style: DrawStyle,
54+ saved: Vec<DrawStyle>,
55+}
56+
57+struct RequestedFont {
58+ size: f64,
59+ weight: u16,
60+ style: Style,
61+ small_caps: bool,
62+}
63+
64+struct GlyphRun {
65+ id: ID,
66+ size: f32,
67+ embolden: bool,
68+ skew_x: f32,
69+ glyphs: Vec<u16>,
70+ positions: Vec<Point>,
71+}
72+
73+pub(crate) struct Graphics {
74+ fonts: Arc<Database>,
75+ features: HashMap<ID, Vec<Feature>>,
76+ font_manager: FontMgr,
77+ typefaces: HashMap<ID, Typeface>,
78+ surfaces: HashMap<u32, Raster>,
79+ next_surface: u32,
80+}
81+
82+impl Graphics {
83+ pub fn new(assets: &[FontAsset]) -> HostResult<Self> {
84+ let mut fonts = Database::new();
85+ let mut features = HashMap::new();
86+ for asset in assets {
87+ let ids = fonts.load_font_source(Source::Binary(Arc::new(asset.data)));
88+ if ids.is_empty() {
89+ return Err(failure(format!("invalid font asset: {}", asset.family)));
90+ }
91+ let parsed_features = asset
92+ .features
93+ .split(',')
94+ .filter(|part| !part.trim().is_empty())
95+ .map(|part| {
96+ Feature::from_str(part.trim())
97+ .map_err(|_| failure(format!("invalid OpenType feature: {part}")))
98+ })
99+ .collect::<HostResult<Vec<_>>>()?;
100+ for id in ids {
101+ let mut face = fonts
102+ .face(id)
103+ .ok_or_else(|| failure("loaded font face is unavailable"))?
104+ .clone();
105+ fonts.remove_face(id);
106+ // Explicit aliases and metadata are authoritative. The same bytes
107+ // may be registered under several CSS names without copying them.
108+ face.families.insert(
109+ 0,
110+ (asset.family.into(), fontdb::Language::English_UnitedStates),
111+ );
112+ face.weight = Weight(asset.weight);
113+ face.style = if asset.italic {
114+ Style::Italic
115+ } else {
116+ Style::Normal
117+ };
118+ let id = fonts.push_face_info(face);
119+ features.insert(id, parsed_features.clone());
120+ }
121+ }
122+ // Supplied faces precede system faces in otherwise identical CSS matches.
123+ fonts.load_system_fonts();
124+ if fonts.is_empty() {
125+ return Err(failure("no fonts are available"));
126+ }
127+ Ok(Self {
128+ fonts: Arc::new(fonts),
129+ features,
130+ font_manager: FontMgr::new(),
131+ typefaces: HashMap::new(),
132+ surfaces: HashMap::new(),
133+ next_surface: 1,
134+ })
135+ }
136+
137+ pub fn measure(&self, shorthand: &str, text: &str) -> HostResult<Metrics> {
138+ self.shape_text(shorthand, text, None)
139+ .map(|(metrics, _, _)| metrics)
140+ }
141+
142+ fn shape_text(
143+ &self,
144+ shorthand: &str,
145+ text: &str,
146+ mut runs: Option<&mut Vec<GlyphRun>>,
147+ ) -> HostResult<(Metrics, ID, f64)> {
148+ let font = svgtypes::FontShorthand::from_str(shorthand)
149+ .map_err(|error| failure(format!("invalid CSS font {shorthand:?}: {error}")))?;
150+ let size = font_size(font.font_size)?;
151+ let families = svgtypes::parse_font_families(font.font_family)?;
152+ let names: Vec<_> = families
153+ .iter()
154+ .map(|family| match family {
155+ svgtypes::FontFamily::Named(name) => Family::Name(name),
156+ svgtypes::FontFamily::Serif => Family::Serif,
157+ svgtypes::FontFamily::SansSerif => Family::SansSerif,
158+ svgtypes::FontFamily::Monospace => Family::Monospace,
159+ svgtypes::FontFamily::Cursive => Family::Cursive,
160+ svgtypes::FontFamily::Fantasy => Family::Fantasy,
161+ })
162+ .collect();
163+ let weight = match font.font_weight.unwrap_or("normal") {
164+ "normal" => 400,
165+ "bold" | "bolder" => 700,
166+ "lighter" => 300,
167+ value => value.parse::<u16>()?,
168+ };
169+ let style = match font.font_style {
170+ Some("italic") => Style::Italic,
171+ Some("oblique") => Style::Oblique,
172+ _ => Style::Normal,
173+ };
174+ let stretch = match font.font_stretch {
175+ Some("ultra-condensed") => Stretch::UltraCondensed,
176+ Some("extra-condensed") => Stretch::ExtraCondensed,
177+ Some("condensed") => Stretch::Condensed,
178+ Some("semi-condensed") => Stretch::SemiCondensed,
179+ Some("semi-expanded") => Stretch::SemiExpanded,
180+ Some("expanded") => Stretch::Expanded,
181+ Some("extra-expanded") => Stretch::ExtraExpanded,
182+ Some("ultra-expanded") => Stretch::UltraExpanded,
183+ _ => Stretch::Normal,
184+ };
185+ let base = self
186+ .fonts
187+ .query(&Query {
188+ families: &names,
189+ weight: Weight(weight),
190+ stretch,
191+ style,
192+ })
193+ .or_else(|| {
194+ self.fonts.query(&Query {
195+ families: &[Family::SansSerif],
196+ weight: Weight(weight),
197+ stretch,
198+ style,
199+ })
200+ })
201+ .or_else(|| self.fonts.faces().next().map(|face| face.id))
202+ .ok_or_else(|| failure(format!("no font matches {shorthand:?}")))?;
203+ let requested = RequestedFont {
204+ size,
205+ weight,
206+ style,
207+ small_caps: font.font_variant == Some("small-caps"),
208+ };
209+ let mut metrics = Metrics::default();
210+ let mut run_start = 0;
211+ let mut run_font = base;
212+ let mut run_script = Script::Common;
213+ // Keep combining marks and emoji sequences together during fallback.
214+ // Script changes split shaping runs, but common punctuation and inherited
215+ // marks retain the surrounding script instead of breaking ligatures.
216+ for (offset, grapheme) in text.grapheme_indices(true) {
217+ let selected = self.fallback(base, grapheme);
218+ let script = grapheme
219+ .chars()
220+ .map(|c| c.script())
221+ .find(|script| !matches!(script, Script::Common | Script::Inherited))
222+ .unwrap_or(run_script);
223+ if offset > run_start
224+ && (selected != run_font || (script != run_script && run_script != Script::Common))
225+ {
226+ self.shape(
227+ run_font,
228+ &text[run_start..offset],
229+ &requested,
230+ &mut metrics,
231+ runs.as_deref_mut(),
232+ )?;
233+ run_start = offset;
234+ }
235+ run_font = selected;
236+ run_script = script;
237+ }
238+ if run_start < text.len() {
239+ self.shape(
240+ run_font,
241+ &text[run_start..],
242+ &requested,
243+ &mut metrics,
244+ runs.as_deref_mut(),
245+ )?;
246+ }
247+ Ok((metrics, base, size))
248+ }
249+
250+ fn supports(&self, id: ID, text: &str) -> bool {
251+ self.fonts.with_face_data(id, |data, index| {
252+ Face::from_slice(data, index).map(|face| text.chars().all(|c| {
253+ // Joiners and variation selectors modify their surrounding glyphs.
254+ matches!(c, '\u{200c}' | '\u{200d}' | '\u{fe00}'..='\u{fe0f}' | '\u{e0100}'..='\u{e01ef}')
255+ || face.glyph_index(c).is_some()
256+ })).unwrap_or(false)
257+ }).unwrap_or(false)
258+ }
259+
260+ fn fallback(&self, base: ID, text: &str) -> ID {
261+ if self.supports(base, text) {
262+ return base;
263+ }
264+ let original = self.fonts.face(base);
265+ self.fonts
266+ .faces()
267+ .filter(|face| {
268+ original
269+ .map(|original| {
270+ face.style == original.style
271+ || face.weight == original.weight
272+ || face.stretch == original.stretch
273+ })
274+ .unwrap_or(true)
275+ })
276+ .find(|face| self.supports(face.id, text))
277+ .map(|face| face.id)
278+ .or_else(|| {
279+ self.fonts
280+ .faces()
281+ .find(|face| self.supports(face.id, text))
282+ .map(|face| face.id)
283+ })
284+ .unwrap_or(base)
285+ }
286+
287+ fn shape(
288+ &self,
289+ id: ID,
290+ text: &str,
291+ requested: &RequestedFont,
292+ metrics: &mut Metrics,
293+ runs: Option<&mut Vec<GlyphRun>>,
294+ ) -> HostResult<()> {
295+ let selected = self
296+ .fonts
297+ .face(id)
298+ .ok_or_else(|| failure("font face is unavailable"))?;
299+ let embolden = requested.weight >= 600 && selected.weight.0 < 600;
300+ let skew_x = if requested.style != Style::Normal && selected.style == Style::Normal {
301+ -0.21255656
302+ } else {
303+ 0.0
304+ };
305+ self.fonts
306+ .with_face_data(id, |data, index| -> HostResult<()> {
307+ let face = Face::from_slice(data, index)
308+ .ok_or_else(|| failure("font could not be shaped"))?;
309+ let scale = requested.size / f64::from(face.units_per_em());
310+ let mut buffer = UnicodeBuffer::new();
311+ buffer.push_str(text);
312+ buffer.guess_segment_properties();
313+ let normal = self.features.get(&id).map(Vec::as_slice).unwrap_or(&[]);
314+ let mut caps = Vec::new();
315+ let features = if requested.small_caps {
316+ caps.extend_from_slice(normal);
317+ caps.push(
318+ Feature::from_str("smcp")
319+ .map_err(|_| failure("invalid small-caps feature"))?,
320+ );
321+ caps.as_slice()
322+ } else {
323+ normal
324+ };
325+ let glyphs = rustybuzz::shape(&face, features, buffer);
326+ let mut advance = 0i64;
327+ let mut y_advance = 0i64;
328+ let mut run = runs.as_ref().map(|_| GlyphRun {
329+ id,
330+ size: requested.size as f32,
331+ embolden,
332+ skew_x,
333+ glyphs: Vec::with_capacity(glyphs.len()),
334+ positions: Vec::with_capacity(glyphs.len()),
335+ });
336+ let total_advance: i64 = glyphs
337+ .glyph_positions()
338+ .iter()
339+ .map(|position| i64::from(position.x_advance))
340+ .sum();
341+ let origin = metrics.width - (total_advance.min(0) as f64) * scale;
342+ for (info, position) in glyphs.glyph_infos().iter().zip(glyphs.glyph_positions()) {
343+ if let Some(run) = &mut run {
344+ run.glyphs.push(info.glyph_id as u16);
345+ run.positions.push(Point::new(
346+ (origin + (advance + i64::from(position.x_offset)) as f64 * scale)
347+ as f32,
348+ (-(y_advance + i64::from(position.y_offset)) as f64 * scale) as f32,
349+ ));
350+ }
351+ y_advance += i64::from(position.y_advance);
352+ advance += i64::from(position.x_advance);
353+ if let Some(bounds) = face
354+ .glyph_bounding_box(rustybuzz::ttf_parser::GlyphId(info.glyph_id as u16))
355+ {
356+ metrics.ascent = metrics
357+ .ascent
358+ .max(f64::from(i32::from(bounds.y_max) + position.y_offset) * scale);
359+ metrics.descent = metrics
360+ .descent
361+ .max(-f64::from(i32::from(bounds.y_min) + position.y_offset) * scale);
362+ }
363+ }
364+ metrics.width += (advance as f64).abs() * scale;
365+ if let (Some(runs), Some(run)) = (runs, run) {
366+ runs.push(run);
367+ }
368+ Ok(())
369+ })
370+ .ok_or_else(|| failure("font bytes are unavailable"))?
371+ }
372+
373+ fn raster(&mut self, id: u32) -> HostResult<&mut Raster> {
374+ self.surfaces
375+ .get_mut(&id)
376+ .ok_or_else(|| failure(format!("unknown canvas surface: {id}")))
377+ }
378+
379+ pub fn create(&mut self, width: i32, height: i32) -> HostResult<u32> {
380+ rgba_size(width, height)?;
381+ let id = self.next_surface;
382+ let next = id
383+ .checked_add(1)
384+ .ok_or_else(|| failure("canvas handles exhausted"))?;
385+ let mut surface = surfaces::raster_n32_premul((width, height))
386+ .ok_or_else(|| failure(format!("could not allocate {width}x{height} canvas")))?;
387+ // Preserve an untouched root clip so reset can discard every user clip.
388+ surface.canvas().save();
389+ self.surfaces.insert(
390+ id,
391+ Raster {
392+ surface,
393+ style: DrawStyle::default(),
394+ saved: Vec::new(),
395+ },
396+ );
397+ self.next_surface = next;
398+ Ok(id)
399+ }
400+
401+ pub fn release(&mut self, id: u32) -> HostResult<()> {
402+ self.surfaces
403+ .remove(&id)
404+ .ok_or_else(|| failure(format!("unknown canvas surface: {id}")))?;
405+ Ok(())
406+ }
407+
408+ pub fn reset(&mut self, id: u32) -> HostResult<()> {
409+ let raster = self.raster(id)?;
410+ let canvas = raster.surface.canvas();
411+ canvas.restore_to_count(1);
412+ canvas.reset_matrix();
413+ canvas.clear(skia_safe::Color::TRANSPARENT);
414+ canvas.save();
415+ raster.style = DrawStyle::default();
416+ raster.saved.clear();
417+ Ok(())
418+ }
419+
420+ pub fn clear(&mut self, id: u32, color: Color) -> HostResult<()> {
421+ self.raster(id)?.surface.canvas().clear(skia_color(color));
422+ Ok(())
423+ }
424+
425+ pub fn save(&mut self, id: u32) -> HostResult<()> {
426+ let raster = self.raster(id)?;
427+ raster.saved.push(raster.style.clone());
428+ raster.surface.canvas().save();
429+ Ok(())
430+ }
431+
432+ pub fn restore(&mut self, id: u32) -> HostResult<()> {
433+ let raster = self.raster(id)?;
434+ raster.style = raster
435+ .saved
436+ .pop()
437+ .ok_or_else(|| failure("canvas restore without matching save"))?;
438+ raster.surface.canvas().restore();
439+ Ok(())
440+ }
441+
442+ pub fn set_transform(&mut self, id: u32, matrix: [f32; 6]) -> HostResult<()> {
443+ let matrix = affine(matrix)?;
444+ self.raster(id)?.surface.canvas().set_matrix(&matrix.into());
445+ Ok(())
446+ }
447+
448+ pub fn transform(&mut self, id: u32, matrix: [f32; 6]) -> HostResult<()> {
449+ let matrix = affine(matrix)?;
450+ self.raster(id)?.surface.canvas().concat(&matrix);
451+ Ok(())
452+ }
453+
454+ pub fn clip(&mut self, id: u32, path: &Path, even_odd: bool) -> HostResult<()> {
455+ // SkPath clones share their immutable point/verb storage.
456+ let mut clip = path.clone();
457+ clip.set_fill_type(if even_odd {
458+ PathFillType::EvenOdd
459+ } else {
460+ PathFillType::Winding
461+ });
462+ self.raster(id)?
463+ .surface
464+ .canvas()
465+ .clip_path(&clip, ClipOp::Intersect, true);
466+ Ok(())
467+ }
468+
469+ pub fn set_blend(&mut self, id: u32, mode: &str) -> HostResult<()> {
470+ let blend = match mode {
471+ "source-over" => BlendMode::SrcOver,
472+ "difference" => BlendMode::Difference,
473+ "destination-out" => BlendMode::DstOut,
474+ "destination-in" => BlendMode::DstIn,
475+ "source-in" => BlendMode::SrcIn,
476+ "copy" => BlendMode::Src,
477+ _ => return Err(failure(format!("unknown canvas blend mode: {mode}"))),
478+ };
479+ self.raster(id)?.style.blend = blend;
480+ Ok(())
481+ }
482+
483+ pub fn set_blur(&mut self, id: u32, radius: f32) -> HostResult<()> {
484+ nonnegative(radius, "blur radius")?;
485+ self.raster(id)?.style.blur = radius;
486+ Ok(())
487+ }
488+
489+ pub fn set_tint(&mut self, id: u32, tint: Option<Color>) -> HostResult<()> {
490+ let filter = tint
491+ .map(|color| {
492+ color_filters::blend(skia_color(color), BlendMode::SrcIn)
493+ .ok_or_else(|| failure("could not create canvas tint"))
494+ })
495+ .transpose()?;
496+ self.raster(id)?.style.tint = filter;
497+ Ok(())
498+ }
499+
500+ pub fn fill_path(&mut self, id: u32, path: &Path, color: Color) -> HostResult<()> {
501+ self.raster(id)?.draw(|canvas, mut paint| {
502+ paint.set_color(skia_color(color));
503+ canvas.draw_path(path, &paint);
504+ })
505+ }
506+
507+ pub fn stroke_path(&mut self, id: u32, path: &Path, stroke: Stroke) -> HostResult<()> {
508+ let (join, cap) = stroke_style(&stroke)?;
509+ self.raster(id)?.draw(|canvas, mut paint| {
510+ set_stroke(&mut paint, &stroke, join, cap);
511+ canvas.draw_path(path, &paint);
512+ })
513+ }
514+
515+ pub fn fill_stroke_path(
516+ &mut self,
517+ id: u32,
518+ path: &Path,
519+ color: Color,
520+ stroke: Stroke,
521+ ) -> HostResult<()> {
522+ // Validate the entire operation before painting its first component.
523+ stroke_style(&stroke)?;
524+ self.fill_path(id, path, color)?;
525+ self.stroke_path(id, path, stroke)
526+ }
527+
528+ pub fn text(
529+ &mut self,
530+ id: u32,
531+ font: &str,
532+ text: &str,
533+ x: f32,
534+ y: f32,
535+ color: Color,
536+ align: i32,
537+ baseline: i32,
538+ ) -> HostResult<()> {
539+ finite(&[x, y], "text position")?;
540+ self.raster(id)?;
541+ if !(0..=2).contains(&align) {
542+ return Err(failure(format!("unknown canvas text alignment: {align}")));
543+ }
544+ if !(0..=3).contains(&baseline) {
545+ return Err(failure(format!("unknown canvas text baseline: {baseline}")));
546+ }
547+ let mut runs = Vec::new();
548+ let (metrics, base, size) = self.shape_text(font, text, Some(&mut runs))?;
549+ let x = x - match align {
550+ 1 => metrics.width as f32 / 2.0,
551+ 2 => metrics.width as f32,
552+ _ => 0.0,
553+ };
554+ for id in std::iter::once(base).chain(runs.iter().map(|run| run.id)) {
555+ if !self.typefaces.contains_key(&id) {
556+ let face = self
557+ .fonts
558+ .with_face_data(id, |data, index| {
559+ self.font_manager.new_from_data(Data::new_copy(data), index)
560+ })
561+ .flatten()
562+ .ok_or_else(|| failure("Skia could not load the shaped font face"))?;
563+ self.typefaces.insert(id, face);
564+ }
565+ }
566+ let typefaces = &self.typefaces;
567+ // Canvas baselines belong to the font, not to the current word's ink.
568+ // Otherwise a reveal from "H" to "Hg" moves the already-visible H.
569+ let y = if baseline == 2 {
570+ y
571+ } else {
572+ let (_, line) = Font::from_typeface(typefaces[&base].clone(), size as f32).metrics();
573+ y + match baseline {
574+ 0 => -line.ascent,
575+ 1 => -(line.ascent + line.descent) / 2.0,
576+ _ => -line.descent,
577+ }
578+ };
579+ let raster = self
580+ .surfaces
581+ .get_mut(&id)
582+ .ok_or_else(|| failure(format!("unknown canvas surface: {id}")))?;
583+ raster.draw(|canvas, mut paint| {
584+ paint.set_color(skia_color(color));
585+ for run in &runs {
586+ let mut font = Font::from_typeface(typefaces[&run.id].clone(), run.size);
587+ // Keep fractional Rustybuzz placement; no independent hinted advances.
588+ font.set_subpixel(true)
589+ .set_hinting(FontHinting::None)
590+ .set_embolden(run.embolden)
591+ .set_skew_x(run.skew_x);
592+ canvas.draw_glyphs_at(&run.glyphs, run.positions.as_slice(), (x, y), &font, &paint);
593+ }
594+ })
595+ }
596+
597+ pub fn circle_pattern(&mut self, id: u32, pattern: CirclePattern) -> HostResult<()> {
598+ finite(&pattern.rect, "pattern rectangle")?;
599+ finite(&pattern.origin, "pattern origin")?;
600+ nonnegative(pattern.radius, "pattern radius")?;
601+ nonnegative(pattern.rect[2], "pattern width")?;
602+ nonnegative(pattern.rect[3], "pattern height")?;
603+ if !pattern.tile.is_finite() || pattern.tile <= 0.0 {
604+ return Err(failure("pattern tile must be positive and finite"));
605+ }
606+ // Record just one periodic tile, not one FFI call or picture per screen dot.
607+ let half = pattern.tile / 2.0;
608+ let tile = Rect::from_xywh(-half, -half, pattern.tile, pattern.tile);
609+ let mut recorder = PictureRecorder::new();
610+ let canvas = recorder.begin_recording(tile, false);
611+ canvas.clear(skia_color(pattern.background));
612+ let mut paint = Paint::default();
613+ paint
614+ .set_anti_alias(true)
615+ .set_color(skia_color(pattern.ink));
616+ // Neighbouring circles must contribute when a radius crosses a tile edge.
617+ let reach = ((pattern.radius as f64 / pattern.tile as f64) + 0.5).floor();
618+ if reach > i32::MAX as f64 {
619+ return Err(failure(
620+ "pattern radius/tile ratio exceeds native coordinate range",
621+ ));
622+ }
623+ let reach = reach as i32;
624+ for row in -reach..=reach {
625+ for column in -reach..=reach {
626+ canvas.draw_circle(
627+ (column as f32 * pattern.tile, row as f32 * pattern.tile),
628+ pattern.radius,
629+ &paint,
630+ );
631+ }
632+ }
633+ let picture = recorder
634+ .finish_recording_as_picture(None)
635+ .ok_or_else(|| failure("could not record circle tile"))?;
636+ let matrix = Matrix::translate((pattern.origin[0], pattern.origin[1]));
637+ let shader = picture.to_shader(
638+ (TileMode::Repeat, TileMode::Repeat),
639+ FilterMode::Linear,
640+ &matrix,
641+ &tile,
642+ );
643+ let [x, y, width, height] = pattern.rect;
644+ self.raster(id)?.draw(|canvas, mut paint| {
645+ paint.set_shader(shader);
646+ canvas.draw_rect(Rect::from_xywh(x, y, width, height), &paint);
647+ })
648+ }
649+
650+ pub fn surface(&mut self, destination: u32, source: u32) -> HostResult<()> {
651+ self.raster(destination)?;
652+ // Raster snapshots share pixels until a writer needs copy-on-write. In
653+ // the normal distinct-surface case this draws without a full-frame copy.
654+ let image = self.raster(source)?.surface.image_snapshot();
655+ self.raster(destination)?.draw(|canvas, paint| {
656+ canvas.draw_image(&image, (0.0, 0.0), Some(&paint));
657+ })
658+ }
659+
660+ pub fn png(&mut self, id: u32, path: &str) -> HostResult<()> {
661+ let pixels = self
662+ .raster(id)?
663+ .surface
664+ .peek_pixels()
665+ .ok_or_else(|| failure("canvas raster pixels are unavailable"))?;
666+ let mut file = std::fs::File::create(path)?;
667+ if !skia_safe::png_encoder::encode(&pixels, &mut file, &Default::default()) {
668+ return Err(failure(format!("could not encode canvas PNG: {path}")));
669+ }
670+ Ok(())
671+ }
672+
673+ pub fn read_rgba(
674+ &mut self,
675+ id: u32,
676+ width: i32,
677+ height: i32,
678+ output: &mut [u8],
679+ ) -> HostResult<()> {
680+ let size = rgba_size(width, height)?;
681+ let raster = self.raster(id)?;
682+ if raster.surface.width() != width || raster.surface.height() != height {
683+ return Err(failure(format!(
684+ "canvas is {}x{}, expected {width}x{height}",
685+ raster.surface.width(),
686+ raster.surface.height(),
687+ )));
688+ }
689+ if output.len() != size {
690+ return Err(failure(format!(
691+ "RGBA buffer has {} bytes, expected {size}",
692+ output.len()
693+ )));
694+ }
695+ let info = ImageInfo::new(
696+ (width, height),
697+ ColorType::RGBA8888,
698+ AlphaType::Unpremul,
699+ None,
700+ );
701+ if !raster
702+ .surface
703+ .read_pixels(&info, output, width as usize * 4, (0, 0))
704+ {
705+ return Err(failure("could not read straight RGBA canvas pixels"));
706+ }
707+ Ok(())
708+ }
709+}
710+
711+impl Default for DrawStyle {
712+ fn default() -> Self {
713+ Self {
714+ blend: BlendMode::SrcOver,
715+ blur: 0.0,
716+ tint: None,
717+ }
718+ }
719+}
720+
721+impl Raster {
722+ fn draw(&mut self, draw: impl FnOnce(&Canvas, Paint)) -> HostResult<()> {
723+ let mut paint = Paint::default();
724+ paint.set_anti_alias(true);
725+ paint.set_blend_mode(self.style.blend);
726+ paint.set_color_filter(self.style.tint.clone());
727+ let canvas = self.surface.canvas();
728+ if self.style.blur == 0.0 {
729+ draw(canvas, paint);
730+ } else {
731+ let filter = image_filters::blur(
732+ (self.style.blur, self.style.blur),
733+ TileMode::Decal,
734+ None,
735+ None,
736+ )
737+ .ok_or_else(|| failure("could not create canvas blur"))?;
738+ paint.set_image_filter(filter);
739+ // Establish the filter layer in device space, then restore the
740+ // geometry transform inside it. Sigma never inherits a zoom/shear.
741+ let matrix = canvas.local_to_device();
742+ let count = canvas.save();
743+ canvas.reset_matrix();
744+ canvas.save_layer(&SaveLayerRec::default().paint(&paint));
745+ canvas.set_matrix(&matrix);
746+ let mut content = Paint::default();
747+ content.set_anti_alias(true);
748+ draw(canvas, content);
749+ canvas.restore_to_count(count);
750+ }
751+ Ok(())
752+ }
753+}
754+
755+pub(crate) fn path_from_values(
756+ mut values: impl Iterator<Item = HostResult<f64>>,
757+) -> HostResult<Path> {
758+ fn coordinate(values: &mut impl Iterator<Item = HostResult<f64>>) -> HostResult<f32> {
759+ let value = values
760+ .next()
761+ .ok_or_else(|| failure("truncated canvas path command"))??;
762+ let coordinate = value as f32;
763+ if !coordinate.is_finite() {
764+ return Err(failure(
765+ "canvas path coordinates must be finite native numbers",
766+ ));
767+ }
768+ Ok(coordinate)
769+ }
770+ fn point(values: &mut impl Iterator<Item = HostResult<f64>>) -> HostResult<Point> {
771+ Ok(Point::new(coordinate(values)?, coordinate(values)?))
772+ }
773+ let mut builder = PathBuilder::new();
774+ let mut has_move = false;
775+ while let Some(tag) = values.next() {
776+ let tag = tag?;
777+ if tag != 1.0 && !has_move && (2.0..=5.0).contains(&tag) {
778+ return Err(failure("canvas path must begin with move-to"));
779+ }
780+ match tag {
781+ 1.0 => {
782+ builder.move_to(point(&mut values)?);
783+ has_move = true;
784+ }
785+ 2.0 => {
786+ builder.line_to(point(&mut values)?);
787+ }
788+ 3.0 => {
789+ let control = point(&mut values)?;
790+ builder.quad_to(control, point(&mut values)?);
791+ }
792+ 4.0 => {
793+ let first = point(&mut values)?;
794+ let second = point(&mut values)?;
795+ builder.cubic_to(first, second, point(&mut values)?);
796+ }
797+ 5.0 => {
798+ builder.close();
799+ }
800+ _ => return Err(failure(format!("unknown canvas path command: {tag}"))),
801+ }
802+ }
803+ Ok(builder.detach())
804+}
805+
806+fn skia_color([r, g, b, a]: Color) -> skia_safe::Color {
807+ skia_safe::Color::from_argb(a, r, g, b)
808+}
809+
810+fn finite(values: &[f32], name: &str) -> HostResult<()> {
811+ if values.iter().all(|value| value.is_finite()) {
812+ Ok(())
813+ } else {
814+ Err(failure(format!(
815+ "{name} must contain finite native numbers"
816+ )))
817+ }
818+}
819+
820+fn nonnegative(value: f32, name: &str) -> HostResult<()> {
821+ if value.is_finite() && value >= 0.0 {
822+ Ok(())
823+ } else {
824+ Err(failure(format!("{name} must be finite and nonnegative")))
825+ }
826+}
827+
828+fn affine([a, b, c, d, e, f]: [f32; 6]) -> HostResult<Matrix> {
829+ finite(&[a, b, c, d, e, f], "canvas transform")?;
830+ Ok(Matrix::new_all(a, c, e, b, d, f, 0.0, 0.0, 1.0))
831+}
832+
833+fn stroke_style(stroke: &Stroke) -> HostResult<(paint::Join, paint::Cap)> {
834+ nonnegative(stroke.width, "stroke width")?;
835+ let join = match stroke.join {
836+ 0 => paint::Join::Round,
837+ 1 => paint::Join::Bevel,
838+ 2 => paint::Join::Miter,
839+ value => return Err(failure(format!("unknown canvas stroke join: {value}"))),
840+ };
841+ let cap = match stroke.cap {
842+ 0 => paint::Cap::Butt,
843+ 1 => paint::Cap::Round,
844+ 2 => paint::Cap::Square,
845+ value => return Err(failure(format!("unknown canvas stroke cap: {value}"))),
846+ };
847+ Ok((join, cap))
848+}
849+
850+fn set_stroke(paint: &mut Paint, stroke: &Stroke, join: paint::Join, cap: paint::Cap) {
851+ paint.set_color(skia_color(stroke.color));
852+ paint.set_style(PaintStyle::Stroke);
853+ paint.set_stroke_width(stroke.width);
854+ paint.set_stroke_join(join);
855+ paint.set_stroke_cap(cap);
856+ paint.set_stroke_miter(4.0);
857+}
858+
859+fn rgba_size(width: i32, height: i32) -> HostResult<usize> {
860+ if width <= 0 || height <= 0 {
861+ return Err(failure("canvas dimensions must be positive"));
862+ }
863+ (width as usize)
864+ .checked_mul(height as usize)
865+ .and_then(|size| size.checked_mul(4))
866+ .ok_or_else(|| failure("canvas dimensions overflow the RGBA buffer size"))
867+}
868+
869+fn font_size(value: &str) -> HostResult<f64> {
870+ let length = svgtypes::Length::from_str(value)?;
871+ let scale = match length.unit {
872+ svgtypes::LengthUnit::None | svgtypes::LengthUnit::Px => 1.0,
873+ svgtypes::LengthUnit::Pt => 96.0 / 72.0,
874+ svgtypes::LengthUnit::Pc => 16.0,
875+ svgtypes::LengthUnit::In => 96.0,
876+ svgtypes::LengthUnit::Cm => 96.0 / 2.54,
877+ svgtypes::LengthUnit::Mm => 96.0 / 25.4,
878+ _ => {
879+ return Err(failure(
880+ "native font measurements require an absolute CSS font size",
881+ ))
882+ }
883+ };
884+ let size = length.number * scale;
885+ if size > 0.0 && (size as f32).is_finite() && (size as f32) > 0.0 {
886+ Ok(size)
887+ } else {
888+ Err(failure(
889+ "font size must be positive and finite in native coordinates",
890+ ))
891+ }
892+}