Use shared text system on Linux and Windows (#10098)

closes #10129
closes #10269

Release Notes:

- N/A

crates/gpui/src/platform.rs

@@ -6,6 +6,9 @@
 mod app_menu;
 mod keystroke;
 
+#[cfg(not(target_os = "macos"))]
+mod cosmic_text;
+
 #[cfg(target_os = "linux")]
 mod linux;
 
@@ -49,6 +52,9 @@ use uuid::Uuid;
 
 pub use app_menu::*;
 pub use keystroke::*;
+
+#[cfg(not(target_os = "macos"))]
+pub(crate) use cosmic_text::*;
 #[cfg(target_os = "linux")]
 pub(crate) use linux::*;
 #[cfg(target_os = "macos")]

crates/gpui/src/platform/cosmic_text.rs

@@ -0,0 +1,3 @@
+mod text_system;
+
+pub(crate) use text_system::*;

crates/gpui/src/platform/cosmic_text/text_system.rs

@@ -18,9 +18,9 @@ use pathfinder_geometry::{
 use smallvec::SmallVec;
 use std::{borrow::Cow, sync::Arc};
 
-pub(crate) struct LinuxTextSystem(RwLock<LinuxTextSystemState>);
+pub(crate) struct CosmicTextSystem(RwLock<CosmicTextSystemState>);
 
-struct LinuxTextSystemState {
+struct CosmicTextSystemState {
     swash_cache: SwashCache,
     font_system: FontSystem,
     /// Contains all already loaded fonts, including all faces. Indexed by `FontId`.
@@ -32,14 +32,14 @@ struct LinuxTextSystemState {
     postscript_names: HashMap<FontId, String>,
 }
 
-impl LinuxTextSystem {
+impl CosmicTextSystem {
     pub(crate) fn new() -> Self {
         let mut font_system = FontSystem::new();
 
         // todo(linux) make font loading non-blocking
         font_system.db_mut().load_system_fonts();
 
-        Self(RwLock::new(LinuxTextSystemState {
+        Self(RwLock::new(CosmicTextSystemState {
             font_system,
             swash_cache: SwashCache::new(),
             loaded_fonts_store: Vec::new(),
@@ -49,13 +49,13 @@ impl LinuxTextSystem {
     }
 }
 
-impl Default for LinuxTextSystem {
+impl Default for CosmicTextSystem {
     fn default() -> Self {
         Self::new()
     }
 }
 
-impl PlatformTextSystem for LinuxTextSystem {
+impl PlatformTextSystem for CosmicTextSystem {
     fn add_fonts(&self, fonts: Vec<Cow<'static, [u8]>>) -> Result<()> {
         self.0.write().add_fonts(fonts)
     }
@@ -189,7 +189,7 @@ impl PlatformTextSystem for LinuxTextSystem {
     }
 }
 
-impl LinuxTextSystemState {
+impl CosmicTextSystemState {
     #[profiling::function]
     fn add_fonts(&mut self, fonts: Vec<Cow<'static, [u8]>>) -> Result<()> {
         let db = self.font_system.db_mut();
@@ -235,8 +235,15 @@ impl LinuxTextSystemState {
                 .get_font(font_id)
                 .ok_or_else(|| anyhow!("Could not load font"))?;
 
-            // HACK: to let the storybook run, we should actually do better font fallback
+            // HACK: To let the storybook run and render Windows caption icons. We should actually do better font fallback.
-            if font.as_swash().charmap().map('m') == 0 || postscript_name == "Segoe Fluent Icons" {
+            let allowed_bad_font_names = [
+                "SegoeFluentIcons", // NOTE: Segoe fluent icons postscript name is inconsistent
+                "Segoe Fluent Icons",
+            ];
+
+            if font.as_swash().charmap().map('m') == 0
+                && !allowed_bad_font_names.contains(&postscript_name.as_str())
+            {
                 self.font_system.db_mut().remove_face(font.id());
                 continue;
             };

crates/gpui/src/platform/linux.rs

@@ -3,12 +3,10 @@
 
 mod dispatcher;
 mod platform;
-mod text_system;
 mod wayland;
 mod x11;
 
 pub(crate) use dispatcher::*;
 pub(crate) use platform::*;
-pub(crate) use text_system::*;
 pub(crate) use wayland::*;
 pub(crate) use x11::*;

crates/gpui/src/platform/linux/platform.rs

@@ -28,8 +28,8 @@ use xkbcommon::xkb::{self, Keycode, Keysym, State};
 
 use crate::platform::linux::wayland::WaylandClient;
 use crate::{
-    px, Action, AnyWindowHandle, BackgroundExecutor, ClipboardItem, CursorStyle, DisplayId,
+    px, Action, AnyWindowHandle, BackgroundExecutor, ClipboardItem, CosmicTextSystem, CursorStyle,
-    ForegroundExecutor, Keymap, Keystroke, LinuxDispatcher, LinuxTextSystem, Menu, Modifiers,
+    DisplayId, ForegroundExecutor, Keymap, Keystroke, LinuxDispatcher, Menu, Modifiers,
     PathPromptOptions, Pixels, Platform, PlatformDisplay, PlatformInput, PlatformInputHandler,
     PlatformTextSystem, PlatformWindow, Point, PromptLevel, Result, SemanticVersion, Size, Task,
     WindowAppearance, WindowOptions, WindowParams,
@@ -134,7 +134,7 @@ pub(crate) struct PlatformHandlers {
 pub(crate) struct LinuxCommon {
     pub(crate) background_executor: BackgroundExecutor,
     pub(crate) foreground_executor: ForegroundExecutor,
-    pub(crate) text_system: Arc<LinuxTextSystem>,
+    pub(crate) text_system: Arc<CosmicTextSystem>,
     pub(crate) callbacks: PlatformHandlers,
     pub(crate) signal: LoopSignal,
 }
@@ -142,7 +142,7 @@ pub(crate) struct LinuxCommon {
 impl LinuxCommon {
     pub fn new(signal: LoopSignal) -> (Self, Channel<Runnable>) {
         let (main_sender, main_receiver) = calloop::channel::channel::<Runnable>();
-        let text_system = Arc::new(LinuxTextSystem::new());
+        let text_system = Arc::new(CosmicTextSystem::new());
         let callbacks = PlatformHandlers::default();
 
         let dispatcher = Arc::new(LinuxDispatcher::new(main_sender));

crates/gpui/src/platform/test/platform.rs

@@ -122,14 +122,11 @@ impl Platform for TestPlatform {
     }
 
     fn text_system(&self) -> Arc<dyn PlatformTextSystem> {
-        #[cfg(target_os = "linux")]
-        return Arc::new(crate::platform::linux::LinuxTextSystem::new());
-
         #[cfg(target_os = "macos")]
         return Arc::new(crate::platform::mac::MacTextSystem::new());
 
-        #[cfg(target_os = "windows")]
+        #[cfg(not(target_os = "macos"))]
-        return Arc::new(crate::platform::windows::WindowsTextSystem::new());
+        return Arc::new(crate::platform::cosmic_text::CosmicTextSystem::new());
     }
 
     fn run(&self, _on_finish_launching: Box<dyn FnOnce()>) {

crates/gpui/src/platform/windows.rs

@@ -1,14 +1,12 @@
 mod dispatcher;
 mod display;
 mod platform;
-mod text_system;
 mod util;
 mod window;
 
 pub(crate) use dispatcher::*;
 pub(crate) use display::*;
 pub(crate) use platform::*;
-pub(crate) use text_system::*;
 pub(crate) use util::*;
 pub(crate) use window::*;
 

crates/gpui/src/platform/windows/platform.rs

@@ -57,7 +57,7 @@ pub(crate) struct WindowsPlatformInner {
     background_executor: BackgroundExecutor,
     pub(crate) foreground_executor: ForegroundExecutor,
     main_receiver: flume::Receiver<Runnable>,
-    text_system: Arc<WindowsTextSystem>,
+    text_system: Arc<CosmicTextSystem>,
     callbacks: Mutex<Callbacks>,
     pub raw_window_handles: RwLock<SmallVec<[HWND; 4]>>,
     pub(crate) dispatch_event: OwnedHandle,
@@ -155,7 +155,7 @@ impl WindowsPlatform {
         let dispatcher = Arc::new(WindowsDispatcher::new(main_sender, dispatch_event.to_raw()));
         let background_executor = BackgroundExecutor::new(dispatcher.clone());
         let foreground_executor = ForegroundExecutor::new(dispatcher);
-        let text_system = Arc::new(WindowsTextSystem::new());
+        let text_system = Arc::new(CosmicTextSystem::new());
         let callbacks = Mutex::new(Callbacks::default());
         let raw_window_handles = RwLock::new(SmallVec::new());
         let settings = RefCell::new(WindowsPlatformSystemSettings::new());

crates/gpui/src/platform/windows/text_system.rs

@@ -1,457 +0,0 @@
-use crate::{
-    point, size, Bounds, DevicePixels, Font, FontFeatures, FontId, FontMetrics, FontRun, FontStyle,
-    FontWeight, GlyphId, LineLayout, Pixels, PlatformTextSystem, Point, RenderGlyphParams,
-    ShapedGlyph, SharedString, Size,
-};
-use anyhow::{anyhow, Context, Ok, Result};
-use collections::HashMap;
-use cosmic_text::Font as CosmicTextFont;
-use cosmic_text::{
-    fontdb::Query, Attrs, AttrsList, BufferLine, CacheKey, Family, FontSystem, SwashCache,
-};
-use parking_lot::{RwLock, RwLockUpgradableReadGuard};
-use pathfinder_geometry::{
-    rect::{RectF, RectI},
-    vector::{Vector2F, Vector2I},
-};
-use smallvec::SmallVec;
-use std::{borrow::Cow, sync::Arc};
-
-pub(crate) struct WindowsTextSystem(RwLock<WindowsTextSystemState>);
-
-struct WindowsTextSystemState {
-    swash_cache: SwashCache,
-    font_system: FontSystem,
-    fonts: Vec<Arc<CosmicTextFont>>,
-    font_selections: HashMap<Font, FontId>,
-    font_ids_by_family_name: HashMap<SharedString, SmallVec<[FontId; 4]>>,
-    postscript_names_by_font_id: HashMap<FontId, String>,
-}
-
-impl WindowsTextSystem {
-    pub(crate) fn new() -> Self {
-        let mut font_system = FontSystem::new();
-        Self(RwLock::new(WindowsTextSystemState {
-            font_system,
-            swash_cache: SwashCache::new(),
-            fonts: Vec::new(),
-            font_selections: HashMap::default(),
-            // font_ids_by_postscript_name: HashMap::default(),
-            font_ids_by_family_name: HashMap::default(),
-            postscript_names_by_font_id: HashMap::default(),
-        }))
-    }
-}
-
-impl Default for WindowsTextSystem {
-    fn default() -> Self {
-        Self::new()
-    }
-}
-
-#[allow(unused)]
-impl PlatformTextSystem for WindowsTextSystem {
-    fn add_fonts(&self, fonts: Vec<Cow<'static, [u8]>>) -> Result<()> {
-        self.0.write().add_fonts(fonts)
-    }
-
-    // todo(windows) ensure that this integrates with platform font loading
-    // do we need to do more than call load_system_fonts()?
-    fn all_font_names(&self) -> Vec<String> {
-        self.0
-            .read()
-            .font_system
-            .db()
-            .faces()
-            .map(|face| face.post_script_name.clone())
-            .collect()
-    }
-
-    // todo(windows)
-    fn all_font_families(&self) -> Vec<String> {
-        Vec::new()
-    }
-
-    fn font_id(&self, font: &Font) -> Result<FontId> {
-        // todo(windows): Do we need to use CosmicText's Font APIs? Can we consolidate this to use font_kit?
-        let lock = self.0.upgradable_read();
-        if let Some(font_id) = lock.font_selections.get(font) {
-            Ok(*font_id)
-        } else {
-            let mut lock = RwLockUpgradableReadGuard::upgrade(lock);
-            let candidates = if let Some(font_ids) = lock.font_ids_by_family_name.get(&font.family)
-            {
-                font_ids.as_slice()
-            } else {
-                let font_ids = lock.load_family(&font.family, font.features)?;
-                lock.font_ids_by_family_name
-                    .insert(font.family.clone(), font_ids);
-                lock.font_ids_by_family_name[&font.family].as_ref()
-            };
-
-            let id = lock
-                .font_system
-                .db()
-                .query(&Query {
-                    families: &[Family::Name(&font.family)],
-                    weight: font.weight.into(),
-                    style: font.style.into(),
-                    stretch: Default::default(),
-                })
-                .context("no font")?;
-
-            let font_id = if let Some(font_id) = lock.fonts.iter().position(|font| font.id() == id)
-            {
-                FontId(font_id)
-            } else {
-                // Font isn't in fonts so add it there, this is because we query all the fonts in the db
-                // and maybe we haven't loaded it yet
-                let font_id = FontId(lock.fonts.len());
-                let font = lock.font_system.get_font(id).unwrap();
-                lock.fonts.push(font);
-                font_id
-            };
-
-            lock.font_selections.insert(font.clone(), font_id);
-            Ok(font_id)
-        }
-    }
-
-    fn font_metrics(&self, font_id: FontId) -> FontMetrics {
-        let metrics = self.0.read().fonts[font_id.0].as_swash().metrics(&[]);
-
-        FontMetrics {
-            units_per_em: metrics.units_per_em as u32,
-            ascent: metrics.ascent,
-            descent: -metrics.descent, // todo(windows) confirm this is correct
-            line_gap: metrics.leading,
-            underline_position: metrics.underline_offset,
-            underline_thickness: metrics.stroke_size,
-            cap_height: metrics.cap_height,
-            x_height: metrics.x_height,
-            // todo(windows): Compute this correctly
-            bounding_box: Bounds {
-                origin: point(0.0, 0.0),
-                size: size(metrics.max_width, metrics.ascent + metrics.descent),
-            },
-        }
-    }
-
-    fn typographic_bounds(&self, font_id: FontId, glyph_id: GlyphId) -> Result<Bounds<f32>> {
-        let lock = self.0.read();
-        let metrics = lock.fonts[font_id.0].as_swash().metrics(&[]);
-        let glyph_metrics = lock.fonts[font_id.0].as_swash().glyph_metrics(&[]);
-        let glyph_id = glyph_id.0 as u16;
-        // todo(windows): Compute this correctly
-        // see https://github.com/servo/font-kit/blob/master/src/loaders/freetype.rs#L614-L620
-        Ok(Bounds {
-            origin: point(0.0, 0.0),
-            size: size(
-                glyph_metrics.advance_width(glyph_id),
-                glyph_metrics.advance_height(glyph_id),
-            ),
-        })
-    }
-
-    fn advance(&self, font_id: FontId, glyph_id: GlyphId) -> Result<Size<f32>> {
-        self.0.read().advance(font_id, glyph_id)
-    }
-
-    fn glyph_for_char(&self, font_id: FontId, ch: char) -> Option<GlyphId> {
-        self.0.read().glyph_for_char(font_id, ch)
-    }
-
-    fn glyph_raster_bounds(&self, params: &RenderGlyphParams) -> Result<Bounds<DevicePixels>> {
-        self.0.write().raster_bounds(params)
-    }
-
-    fn rasterize_glyph(
-        &self,
-        params: &RenderGlyphParams,
-        raster_bounds: Bounds<DevicePixels>,
-    ) -> Result<(Size<DevicePixels>, Vec<u8>)> {
-        self.0.write().rasterize_glyph(params, raster_bounds)
-    }
-
-    fn layout_line(&self, text: &str, font_size: Pixels, runs: &[FontRun]) -> LineLayout {
-        self.0.write().layout_line(text, font_size, runs)
-    }
-
-    // todo(windows) Confirm that this has been superseded by the LineWrapper
-    fn wrap_line(
-        &self,
-        text: &str,
-        font_id: FontId,
-        font_size: Pixels,
-        width: Pixels,
-    ) -> Vec<usize> {
-        unimplemented!()
-    }
-}
-
-impl WindowsTextSystemState {
-    #[profiling::function]
-    fn add_fonts(&mut self, fonts: Vec<Cow<'static, [u8]>>) -> Result<()> {
-        let db = self.font_system.db_mut();
-        for bytes in fonts {
-            match bytes {
-                Cow::Borrowed(embedded_font) => {
-                    db.load_font_data(embedded_font.to_vec());
-                }
-                Cow::Owned(bytes) => {
-                    db.load_font_data(bytes);
-                }
-            }
-        }
-        Ok(())
-    }
-
-    #[profiling::function]
-    fn load_family(
-        &mut self,
-        name: &str,
-        _features: FontFeatures,
-    ) -> Result<SmallVec<[FontId; 4]>> {
-        // TODO: Determine the proper system UI font.
-        let name = if name == ".SystemUIFont" {
-            "Zed Sans"
-        } else {
-            name
-        };
-
-        let mut font_ids = SmallVec::new();
-        let families = self
-            .font_system
-            .db()
-            .faces()
-            .filter(|face| face.families.iter().any(|family| *name == family.0))
-            .map(|face| (face.id, face.post_script_name.clone()))
-            .collect::<SmallVec<[_; 4]>>();
-
-        for (font_id, postscript_name) in families {
-            let font = self
-                .font_system
-                .get_font(font_id)
-                .ok_or_else(|| anyhow!("Could not load font"))?;
-            // TODO: figure out why this is causing fluent icons from loading
-            // if font.as_swash().charmap().map('m') == 0 {
-            //     self.font_system.db_mut().remove_face(font.id());
-            //     continue;
-            // };
-
-            let font_id = FontId(self.fonts.len());
-            font_ids.push(font_id);
-            self.fonts.push(font);
-            self.postscript_names_by_font_id
-                .insert(font_id, postscript_name);
-        }
-        Ok(font_ids)
-    }
-
-    fn advance(&self, font_id: FontId, glyph_id: GlyphId) -> Result<Size<f32>> {
-        let width = self.fonts[font_id.0]
-            .as_swash()
-            .glyph_metrics(&[])
-            .advance_width(glyph_id.0 as u16);
-        let height = self.fonts[font_id.0]
-            .as_swash()
-            .glyph_metrics(&[])
-            .advance_height(glyph_id.0 as u16);
-        Ok(Size { width, height })
-    }
-
-    fn glyph_for_char(&self, font_id: FontId, ch: char) -> Option<GlyphId> {
-        let glyph_id = self.fonts[font_id.0].as_swash().charmap().map(ch);
-        if glyph_id == 0 {
-            None
-        } else {
-            Some(GlyphId(glyph_id.into()))
-        }
-    }
-
-    fn is_emoji(&self, font_id: FontId) -> bool {
-        // todo(windows): implement this correctly
-        self.postscript_names_by_font_id
-            .get(&font_id)
-            .map_or(false, |postscript_name| {
-                postscript_name == "AppleColorEmoji"
-            })
-    }
-
-    // todo(windows) both raster functions have problems because I am not sure this is the correct mapping from cosmic text to gpui system
-    fn raster_bounds(&mut self, params: &RenderGlyphParams) -> Result<Bounds<DevicePixels>> {
-        let font = &self.fonts[params.font_id.0];
-        let font_system = &mut self.font_system;
-        let image = self
-            .swash_cache
-            .get_image(
-                font_system,
-                CacheKey::new(
-                    font.id(),
-                    params.glyph_id.0 as u16,
-                    (params.font_size * params.scale_factor).into(),
-                    (0.0, 0.0),
-                    cosmic_text::CacheKeyFlags::empty(),
-                )
-                .0,
-            )
-            .clone()
-            .unwrap();
-        Ok(Bounds {
-            origin: point(image.placement.left.into(), (-image.placement.top).into()),
-            size: size(image.placement.width.into(), image.placement.height.into()),
-        })
-    }
-
-    #[profiling::function]
-    fn rasterize_glyph(
-        &mut self,
-        params: &RenderGlyphParams,
-        glyph_bounds: Bounds<DevicePixels>,
-    ) -> Result<(Size<DevicePixels>, Vec<u8>)> {
-        if glyph_bounds.size.width.0 == 0 || glyph_bounds.size.height.0 == 0 {
-            Err(anyhow!("glyph bounds are empty"))
-        } else {
-            // todo(windows) handle subpixel variants
-            let bitmap_size = glyph_bounds.size;
-            let font = &self.fonts[params.font_id.0];
-            let font_system = &mut self.font_system;
-            let image = self
-                .swash_cache
-                .get_image(
-                    font_system,
-                    CacheKey::new(
-                        font.id(),
-                        params.glyph_id.0 as u16,
-                        (params.font_size * params.scale_factor).into(),
-                        (0.0, 0.0),
-                        cosmic_text::CacheKeyFlags::empty(),
-                    )
-                    .0,
-                )
-                .clone()
-                .unwrap();
-
-            Ok((bitmap_size, image.data))
-        }
-    }
-
-    // todo(windows) This is all a quick first pass, maybe we should be using cosmic_text::Buffer
-    #[profiling::function]
-    fn layout_line(&mut self, text: &str, font_size: Pixels, font_runs: &[FontRun]) -> LineLayout {
-        let mut attrs_list = AttrsList::new(Attrs::new());
-        let mut offs = 0;
-        for run in font_runs {
-            // todo(windows) We need to check we are doing utf properly
-            let font = &self.fonts[run.font_id.0];
-            let font = self.font_system.db().face(font.id()).unwrap();
-            attrs_list.add_span(
-                offs..offs + run.len,
-                Attrs::new()
-                    .family(Family::Name(&font.families.first().unwrap().0))
-                    .stretch(font.stretch)
-                    .style(font.style)
-                    .weight(font.weight),
-            );
-            offs += run.len;
-        }
-        let mut line = BufferLine::new(text, attrs_list, cosmic_text::Shaping::Advanced);
-        let layout = line.layout(
-            &mut self.font_system,
-            font_size.0,
-            f32::MAX, // todo(windows) we don't have a width cause this should technically not be wrapped I believe
-            cosmic_text::Wrap::None,
-            None,
-        );
-        let mut runs = Vec::new();
-        // todo(windows) what I think can happen is layout returns possibly multiple lines which means we should be probably working with it higher up in the text rendering
-        let layout = layout.first().unwrap();
-        for glyph in &layout.glyphs {
-            let font_id = glyph.font_id;
-            let font_id = FontId(
-                self.fonts
-                    .iter()
-                    .position(|font| font.id() == font_id)
-                    .unwrap(),
-            );
-            let mut glyphs = SmallVec::new();
-            // todo(windows) this is definitely wrong, each glyph in glyphs from cosmic-text is a cluster with one glyph, ShapedRun takes a run of glyphs with the same font and direction
-            glyphs.push(ShapedGlyph {
-                id: GlyphId(glyph.glyph_id as u32),
-                position: point((glyph.x).into(), glyph.y.into()),
-                index: glyph.start,
-                is_emoji: self.is_emoji(font_id),
-            });
-            runs.push(crate::ShapedRun { font_id, glyphs });
-        }
-        LineLayout {
-            font_size,
-            width: layout.w.into(),
-            ascent: layout.max_ascent.into(),
-            descent: layout.max_descent.into(),
-            runs,
-            len: text.len(),
-        }
-    }
-}
-
-impl From<RectF> for Bounds<f32> {
-    fn from(rect: RectF) -> Self {
-        Bounds {
-            origin: point(rect.origin_x(), rect.origin_y()),
-            size: size(rect.width(), rect.height()),
-        }
-    }
-}
-
-impl From<RectI> for Bounds<DevicePixels> {
-    fn from(rect: RectI) -> Self {
-        Bounds {
-            origin: point(DevicePixels(rect.origin_x()), DevicePixels(rect.origin_y())),
-            size: size(DevicePixels(rect.width()), DevicePixels(rect.height())),
-        }
-    }
-}
-
-impl From<Vector2I> for Size<DevicePixels> {
-    fn from(value: Vector2I) -> Self {
-        size(value.x().into(), value.y().into())
-    }
-}
-
-impl From<RectI> for Bounds<i32> {
-    fn from(rect: RectI) -> Self {
-        Bounds {
-            origin: point(rect.origin_x(), rect.origin_y()),
-            size: size(rect.width(), rect.height()),
-        }
-    }
-}
-
-impl From<Point<u32>> for Vector2I {
-    fn from(size: Point<u32>) -> Self {
-        Vector2I::new(size.x as i32, size.y as i32)
-    }
-}
-
-impl From<Vector2F> for Size<f32> {
-    fn from(vec: Vector2F) -> Self {
-        size(vec.x(), vec.y())
-    }
-}
-
-impl From<FontWeight> for cosmic_text::Weight {
-    fn from(value: FontWeight) -> Self {
-        cosmic_text::Weight(value.0 as u16)
-    }
-}
-
-impl From<FontStyle> for cosmic_text::Style {
-    fn from(style: FontStyle) -> Self {
-        match style {
-            FontStyle::Normal => cosmic_text::Style::Normal,
-            FontStyle::Italic => cosmic_text::Style::Italic,
-            FontStyle::Oblique => cosmic_text::Style::Oblique,
-        }
-    }
-}