Implement vectorial text support for `iced_tiny_skia`

1 files changed, 2 insertions, 140 deletions

diff --git a/wgpu/src/geometry.rs b/wgpu/src/geometry.rs
index a1583a07..4d7f443e 100644
--- a/wgpu/src/geometry.rs
+++ b/wgpu/src/geometry.rs
@@ -1,7 +1,6 @@
 //! Build and draw geometry.
-use crate::core::alignment;
 use crate::core::text::LineHeight;
-use crate::core::{Color, Pixels, Point, Rectangle, Size, Vector};
+use crate::core::{Pixels, Point, Rectangle, Size, Vector};
 use crate::graphics::color;
 use crate::graphics::geometry::fill::{self, Fill};
 use crate::graphics::geometry::{
@@ -9,7 +8,6 @@ use crate::graphics::geometry::{
 };
 use crate::graphics::gradient::{self, Gradient};
 use crate::graphics::mesh::{self, Mesh};
-use crate::graphics::text::{self, cosmic_text};
 use crate::primitive::{self, Primitive};
 
 use lyon::geom::euclid;
@@ -380,143 +378,7 @@ impl Frame {
                 clip_bounds: Rectangle::with_size(Size::INFINITY),
             });
         } else {
-            let mut font_system =
-                text::font_system().write().expect("Write font system");
-
-            let mut buffer = cosmic_text::BufferLine::new(
-                &text.content,
-                cosmic_text::AttrsList::new(text::to_attributes(text.font)),
-                text::to_shaping(text.shaping),
-            );
-
-            let layout = buffer.layout(
-                font_system.raw(),
-                text.size.0,
-                f32::MAX,
-                cosmic_text::Wrap::None,
-            );
-
-            let translation_x = match text.horizontal_alignment {
-                alignment::Horizontal::Left => text.position.x,
-                alignment::Horizontal::Center
-                | alignment::Horizontal::Right => {
-                    let mut line_width = 0.0f32;
-
-                    for line in layout.iter() {
-                        line_width = line_width.max(line.w);
-                    }
-
-                    if text.horizontal_alignment
-                        == alignment::Horizontal::Center
-                    {
-                        text.position.x - line_width / 2.0
-                    } else {
-                        text.position.x - line_width
-                    }
-                }
-            };
-
-            let translation_y = {
-                let line_height = text.line_height.to_absolute(text.size);
-
-                match text.vertical_alignment {
-                    alignment::Vertical::Top => text.position.y,
-                    alignment::Vertical::Center => {
-                        text.position.y - line_height.0 / 2.0
-                    }
-                    alignment::Vertical::Bottom => {
-                        text.position.y - line_height.0
-                    }
-                }
-            };
-
-            let mut swash_cache = cosmic_text::SwashCache::new();
-
-            for run in layout.iter() {
-                for glyph in run.glyphs.iter() {
-                    let physical_glyph = glyph.physical((0.0, 0.0), 1.0);
-
-                    let start_x = translation_x + glyph.x + glyph.x_offset;
-                    let start_y = translation_y + glyph.y_offset + text.size.0;
-                    let offset = Vector::new(start_x, start_y);
-
-                    if let Some(commands) = swash_cache.get_outline_commands(
-                        font_system.raw(),
-                        physical_glyph.cache_key,
-                    ) {
-                        let glyph = Path::new(|path| {
-                            use cosmic_text::Command;
-
-                            for command in commands {
-                                match command {
-                                    Command::MoveTo(p) => {
-                                        path.move_to(
-                                            Point::new(p.x, -p.y) + offset,
-                                        );
-                                    }
-                                    Command::LineTo(p) => {
-                                        path.line_to(
-                                            Point::new(p.x, -p.y) + offset,
-                                        );
-                                    }
-                                    Command::CurveTo(
-                                        control_a,
-                                        control_b,
-                                        to,
-                                    ) => {
-                                        path.bezier_curve_to(
-                                            Point::new(
-                                                control_a.x,
-                                                -control_a.y,
-                                            ) + offset,
-                                            Point::new(
-                                                control_b.x,
-                                                -control_b.y,
-                                            ) + offset,
-                                            Point::new(to.x, -to.y) + offset,
-                                        );
-                                    }
-                                    Command::QuadTo(control, to) => {
-                                        path.quadratic_curve_to(
-                                            Point::new(control.x, -control.y)
-                                                + offset,
-                                            Point::new(to.x, -to.y) + offset,
-                                        );
-                                    }
-                                    Command::Close => {
-                                        path.close();
-                                    }
-                                }
-                            }
-                        });
-
-                        self.fill(&glyph, text.color);
-                    } else {
-                        // TODO: Raster image support for `Canvas`
-                        let [r, g, b, a] = text.color.into_rgba8();
-
-                        swash_cache.with_pixels(
-                            font_system.raw(),
-                            physical_glyph.cache_key,
-                            cosmic_text::Color::rgba(r, g, b, a),
-                            |x, y, color| {
-                                self.fill(
-                                    &Path::rectangle(
-                                        Point::new(x as f32, y as f32) + offset,
-                                        Size::new(1.0, 1.0),
-                                    ),
-                                    Color::from_rgba8(
-                                        color.r(),
-                                        color.g(),
-                                        color.b(),
-                                        color.a() as f32 / 255.0,
-                                    ),
-                                );
-                            },
-                        )
-                    }
-                }
-            }
+            text.draw_with(|path, color| self.fill(&path, color));
         }
     }