Remove 2 suffix from gpui

Co-authored-by: Mikayla <mikayla@zed.dev>

crates/gpui/src/text_system.rs

@@ -0,0 +1,628 @@
+mod font_features;
+mod line;
+mod line_layout;
+mod line_wrapper;
+
+pub use font_features::*;
+pub use line::*;
+pub use line_layout::*;
+pub use line_wrapper::*;
+
+use crate::{
+    px, Bounds, DevicePixels, Hsla, Pixels, PlatformTextSystem, Point, Result, SharedString, Size,
+    UnderlineStyle,
+};
+use anyhow::anyhow;
+use collections::FxHashMap;
+use core::fmt;
+use parking_lot::{Mutex, RwLock, RwLockUpgradableReadGuard};
+use smallvec::SmallVec;
+use std::{
+    cmp,
+    fmt::{Debug, Display, Formatter},
+    hash::{Hash, Hasher},
+    ops::{Deref, DerefMut},
+    sync::Arc,
+};
+
+#[derive(Hash, PartialEq, Eq, Clone, Copy, Debug)]
+#[repr(C)]
+pub struct FontId(pub usize);
+
+#[derive(Hash, PartialEq, Eq, Clone, Copy, Debug)]
+pub struct FontFamilyId(pub usize);
+
+pub const SUBPIXEL_VARIANTS: u8 = 4;
+
+pub struct TextSystem {
+    line_layout_cache: Arc<LineLayoutCache>,
+    platform_text_system: Arc<dyn PlatformTextSystem>,
+    font_ids_by_font: RwLock<FxHashMap<Font, FontId>>,
+    font_metrics: RwLock<FxHashMap<FontId, FontMetrics>>,
+    raster_bounds: RwLock<FxHashMap<RenderGlyphParams, Bounds<DevicePixels>>>,
+    wrapper_pool: Mutex<FxHashMap<FontIdWithSize, Vec<LineWrapper>>>,
+    font_runs_pool: Mutex<Vec<Vec<FontRun>>>,
+}
+
+impl TextSystem {
+    pub fn new(platform_text_system: Arc<dyn PlatformTextSystem>) -> Self {
+        TextSystem {
+            line_layout_cache: Arc::new(LineLayoutCache::new(platform_text_system.clone())),
+            platform_text_system,
+            font_metrics: RwLock::default(),
+            raster_bounds: RwLock::default(),
+            font_ids_by_font: RwLock::default(),
+            wrapper_pool: Mutex::default(),
+            font_runs_pool: Mutex::default(),
+        }
+    }
+
+    pub fn add_fonts(&self, fonts: &[Arc<Vec<u8>>]) -> Result<()> {
+        self.platform_text_system.add_fonts(fonts)
+    }
+
+    pub fn font_id(&self, font: &Font) -> Result<FontId> {
+        let font_id = self.font_ids_by_font.read().get(font).copied();
+        if let Some(font_id) = font_id {
+            Ok(font_id)
+        } else {
+            let font_id = self.platform_text_system.font_id(font)?;
+            self.font_ids_by_font.write().insert(font.clone(), font_id);
+            Ok(font_id)
+        }
+    }
+
+    pub fn bounding_box(&self, font_id: FontId, font_size: Pixels) -> Bounds<Pixels> {
+        self.read_metrics(font_id, |metrics| metrics.bounding_box(font_size))
+    }
+
+    pub fn typographic_bounds(
+        &self,
+        font_id: FontId,
+        font_size: Pixels,
+        character: char,
+    ) -> Result<Bounds<Pixels>> {
+        let glyph_id = self
+            .platform_text_system
+            .glyph_for_char(font_id, character)
+            .ok_or_else(|| anyhow!("glyph not found for character '{}'", character))?;
+        let bounds = self
+            .platform_text_system
+            .typographic_bounds(font_id, glyph_id)?;
+        Ok(self.read_metrics(font_id, |metrics| {
+            (bounds / metrics.units_per_em as f32 * font_size.0).map(px)
+        }))
+    }
+
+    pub fn advance(&self, font_id: FontId, font_size: Pixels, ch: char) -> Result<Size<Pixels>> {
+        let glyph_id = self
+            .platform_text_system
+            .glyph_for_char(font_id, ch)
+            .ok_or_else(|| anyhow!("glyph not found for character '{}'", ch))?;
+        let result = self.platform_text_system.advance(font_id, glyph_id)?
+            / self.units_per_em(font_id) as f32;
+
+        Ok(result * font_size)
+    }
+
+    pub fn units_per_em(&self, font_id: FontId) -> u32 {
+        self.read_metrics(font_id, |metrics| metrics.units_per_em)
+    }
+
+    pub fn cap_height(&self, font_id: FontId, font_size: Pixels) -> Pixels {
+        self.read_metrics(font_id, |metrics| metrics.cap_height(font_size))
+    }
+
+    pub fn x_height(&self, font_id: FontId, font_size: Pixels) -> Pixels {
+        self.read_metrics(font_id, |metrics| metrics.x_height(font_size))
+    }
+
+    pub fn ascent(&self, font_id: FontId, font_size: Pixels) -> Pixels {
+        self.read_metrics(font_id, |metrics| metrics.ascent(font_size))
+    }
+
+    pub fn descent(&self, font_id: FontId, font_size: Pixels) -> Pixels {
+        self.read_metrics(font_id, |metrics| metrics.descent(font_size))
+    }
+
+    pub fn baseline_offset(
+        &self,
+        font_id: FontId,
+        font_size: Pixels,
+        line_height: Pixels,
+    ) -> Pixels {
+        let ascent = self.ascent(font_id, font_size);
+        let descent = self.descent(font_id, font_size);
+        let padding_top = (line_height - ascent - descent) / 2.;
+        padding_top + ascent
+    }
+
+    fn read_metrics<T>(&self, font_id: FontId, read: impl FnOnce(&FontMetrics) -> T) -> T {
+        let lock = self.font_metrics.upgradable_read();
+
+        if let Some(metrics) = lock.get(&font_id) {
+            read(metrics)
+        } else {
+            let mut lock = RwLockUpgradableReadGuard::upgrade(lock);
+            let metrics = lock
+                .entry(font_id)
+                .or_insert_with(|| self.platform_text_system.font_metrics(font_id));
+            read(metrics)
+        }
+    }
+
+    pub fn layout_line(
+        &self,
+        text: &str,
+        font_size: Pixels,
+        runs: &[TextRun],
+    ) -> Result<Arc<LineLayout>> {
+        let mut font_runs = self.font_runs_pool.lock().pop().unwrap_or_default();
+        for run in runs.iter() {
+            let font_id = self.font_id(&run.font)?;
+            if let Some(last_run) = font_runs.last_mut() {
+                if last_run.font_id == font_id {
+                    last_run.len += run.len;
+                    continue;
+                }
+            }
+            font_runs.push(FontRun {
+                len: run.len,
+                font_id,
+            });
+        }
+
+        let layout = self
+            .line_layout_cache
+            .layout_line(text, font_size, &font_runs);
+
+        font_runs.clear();
+        self.font_runs_pool.lock().push(font_runs);
+
+        Ok(layout)
+    }
+
+    pub fn shape_line(
+        &self,
+        text: SharedString,
+        font_size: Pixels,
+        runs: &[TextRun],
+    ) -> Result<ShapedLine> {
+        debug_assert!(
+            text.find('\n').is_none(),
+            "text argument should not contain newlines"
+        );
+
+        let mut decoration_runs = SmallVec::<[DecorationRun; 32]>::new();
+        for run in runs {
+            if let Some(last_run) = decoration_runs.last_mut() {
+                if last_run.color == run.color
+                    && last_run.underline == run.underline
+                    && last_run.background_color == run.background_color
+                {
+                    last_run.len += run.len as u32;
+                    continue;
+                }
+            }
+            decoration_runs.push(DecorationRun {
+                len: run.len as u32,
+                color: run.color,
+                background_color: run.background_color,
+                underline: run.underline,
+            });
+        }
+
+        let layout = self.layout_line(text.as_ref(), font_size, runs)?;
+
+        Ok(ShapedLine {
+            layout,
+            text,
+            decoration_runs,
+        })
+    }
+
+    pub fn shape_text(
+        &self,
+        text: &str, // todo!("pass a SharedString and preserve it when passed a single line?")
+        font_size: Pixels,
+        runs: &[TextRun],
+        wrap_width: Option<Pixels>,
+    ) -> Result<SmallVec<[WrappedLine; 1]>> {
+        let mut runs = runs.iter().cloned().peekable();
+        let mut font_runs = self.font_runs_pool.lock().pop().unwrap_or_default();
+
+        let mut lines = SmallVec::new();
+        let mut line_start = 0;
+        for line_text in text.split('\n') {
+            let line_text = SharedString::from(line_text.to_string());
+            let line_end = line_start + line_text.len();
+
+            let mut last_font: Option<Font> = None;
+            let mut decoration_runs = SmallVec::<[DecorationRun; 32]>::new();
+            let mut run_start = line_start;
+            while run_start < line_end {
+                let Some(run) = runs.peek_mut() else {
+                    break;
+                };
+
+                let run_len_within_line = cmp::min(line_end, run_start + run.len) - run_start;
+
+                if last_font == Some(run.font.clone()) {
+                    font_runs.last_mut().unwrap().len += run_len_within_line;
+                } else {
+                    last_font = Some(run.font.clone());
+                    font_runs.push(FontRun {
+                        len: run_len_within_line,
+                        font_id: self.platform_text_system.font_id(&run.font)?,
+                    });
+                }
+
+                if decoration_runs.last().map_or(false, |last_run| {
+                    last_run.color == run.color
+                        && last_run.underline == run.underline
+                        && last_run.background_color == run.background_color
+                }) {
+                    decoration_runs.last_mut().unwrap().len += run_len_within_line as u32;
+                } else {
+                    decoration_runs.push(DecorationRun {
+                        len: run_len_within_line as u32,
+                        color: run.color,
+                        background_color: run.background_color,
+                        underline: run.underline,
+                    });
+                }
+
+                if run_len_within_line == run.len {
+                    runs.next();
+                } else {
+                    // Preserve the remainder of the run for the next line
+                    run.len -= run_len_within_line;
+                }
+                run_start += run_len_within_line;
+            }
+
+            let layout = self
+                .line_layout_cache
+                .layout_wrapped_line(&line_text, font_size, &font_runs, wrap_width);
+            lines.push(WrappedLine {
+                layout,
+                decoration_runs,
+                text: line_text,
+            });
+
+            // Skip `\n` character.
+            line_start = line_end + 1;
+            if let Some(run) = runs.peek_mut() {
+                run.len = run.len.saturating_sub(1);
+                if run.len == 0 {
+                    runs.next();
+                }
+            }
+
+            font_runs.clear();
+        }
+
+        self.font_runs_pool.lock().push(font_runs);
+
+        Ok(lines)
+    }
+
+    pub fn start_frame(&self) {
+        self.line_layout_cache.start_frame()
+    }
+
+    pub fn line_wrapper(
+        self: &Arc<Self>,
+        font: Font,
+        font_size: Pixels,
+    ) -> Result<LineWrapperHandle> {
+        let lock = &mut self.wrapper_pool.lock();
+        let font_id = self.font_id(&font)?;
+        let wrappers = lock
+            .entry(FontIdWithSize { font_id, font_size })
+            .or_default();
+        let wrapper = wrappers.pop().map(anyhow::Ok).unwrap_or_else(|| {
+            Ok(LineWrapper::new(
+                font_id,
+                font_size,
+                self.platform_text_system.clone(),
+            ))
+        })?;
+
+        Ok(LineWrapperHandle {
+            wrapper: Some(wrapper),
+            text_system: self.clone(),
+        })
+    }
+
+    pub fn raster_bounds(&self, params: &RenderGlyphParams) -> Result<Bounds<DevicePixels>> {
+        let raster_bounds = self.raster_bounds.upgradable_read();
+        if let Some(bounds) = raster_bounds.get(params) {
+            Ok(*bounds)
+        } else {
+            let mut raster_bounds = RwLockUpgradableReadGuard::upgrade(raster_bounds);
+            let bounds = self.platform_text_system.glyph_raster_bounds(params)?;
+            raster_bounds.insert(params.clone(), bounds);
+            Ok(bounds)
+        }
+    }
+
+    pub fn rasterize_glyph(
+        &self,
+        params: &RenderGlyphParams,
+    ) -> Result<(Size<DevicePixels>, Vec<u8>)> {
+        let raster_bounds = self.raster_bounds(params)?;
+        self.platform_text_system
+            .rasterize_glyph(params, raster_bounds)
+    }
+}
+
+#[derive(Hash, Eq, PartialEq)]
+struct FontIdWithSize {
+    font_id: FontId,
+    font_size: Pixels,
+}
+
+pub struct LineWrapperHandle {
+    wrapper: Option<LineWrapper>,
+    text_system: Arc<TextSystem>,
+}
+
+impl Drop for LineWrapperHandle {
+    fn drop(&mut self) {
+        let mut state = self.text_system.wrapper_pool.lock();
+        let wrapper = self.wrapper.take().unwrap();
+        state
+            .get_mut(&FontIdWithSize {
+                font_id: wrapper.font_id,
+                font_size: wrapper.font_size,
+            })
+            .unwrap()
+            .push(wrapper);
+    }
+}
+
+impl Deref for LineWrapperHandle {
+    type Target = LineWrapper;
+
+    fn deref(&self) -> &Self::Target {
+        self.wrapper.as_ref().unwrap()
+    }
+}
+
+impl DerefMut for LineWrapperHandle {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        self.wrapper.as_mut().unwrap()
+    }
+}
+
+/// The degree of blackness or stroke thickness of a font. This value ranges from 100.0 to 900.0,
+/// with 400.0 as normal.
+#[derive(Clone, Copy, Debug, PartialEq, PartialOrd)]
+pub struct FontWeight(pub f32);
+
+impl Default for FontWeight {
+    #[inline]
+    fn default() -> FontWeight {
+        FontWeight::NORMAL
+    }
+}
+
+impl Hash for FontWeight {
+    fn hash<H: Hasher>(&self, state: &mut H) {
+        state.write_u32(u32::from_be_bytes(self.0.to_be_bytes()));
+    }
+}
+
+impl Eq for FontWeight {}
+
+impl FontWeight {
+    /// Thin weight (100), the thinnest value.
+    pub const THIN: FontWeight = FontWeight(100.0);
+    /// Extra light weight (200).
+    pub const EXTRA_LIGHT: FontWeight = FontWeight(200.0);
+    /// Light weight (300).
+    pub const LIGHT: FontWeight = FontWeight(300.0);
+    /// Normal (400).
+    pub const NORMAL: FontWeight = FontWeight(400.0);
+    /// Medium weight (500, higher than normal).
+    pub const MEDIUM: FontWeight = FontWeight(500.0);
+    /// Semibold weight (600).
+    pub const SEMIBOLD: FontWeight = FontWeight(600.0);
+    /// Bold weight (700).
+    pub const BOLD: FontWeight = FontWeight(700.0);
+    /// Extra-bold weight (800).
+    pub const EXTRA_BOLD: FontWeight = FontWeight(800.0);
+    /// Black weight (900), the thickest value.
+    pub const BLACK: FontWeight = FontWeight(900.0);
+}
+
+/// Allows italic or oblique faces to be selected.
+#[derive(Clone, Copy, Eq, PartialEq, Debug, Hash, Default)]
+pub enum FontStyle {
+    /// A face that is neither italic not obliqued.
+    #[default]
+    Normal,
+    /// A form that is generally cursive in nature.
+    Italic,
+    /// A typically-sloped version of the regular face.
+    Oblique,
+}
+
+impl Display for FontStyle {
+    fn fmt(&self, f: &mut Formatter) -> fmt::Result {
+        Debug::fmt(self, f)
+    }
+}
+
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct TextRun {
+    // number of utf8 bytes
+    pub len: usize,
+    pub font: Font,
+    pub color: Hsla,
+    pub background_color: Option<Hsla>,
+    pub underline: Option<UnderlineStyle>,
+}
+
+#[derive(Copy, Clone, Debug, Eq, PartialEq, Hash)]
+#[repr(C)]
+pub struct GlyphId(u32);
+
+impl From<GlyphId> for u32 {
+    fn from(value: GlyphId) -> Self {
+        value.0
+    }
+}
+
+impl From<u16> for GlyphId {
+    fn from(num: u16) -> Self {
+        GlyphId(num as u32)
+    }
+}
+
+impl From<u32> for GlyphId {
+    fn from(num: u32) -> Self {
+        GlyphId(num)
+    }
+}
+
+#[derive(Clone, Debug, PartialEq)]
+pub struct RenderGlyphParams {
+    pub(crate) font_id: FontId,
+    pub(crate) glyph_id: GlyphId,
+    pub(crate) font_size: Pixels,
+    pub(crate) subpixel_variant: Point<u8>,
+    pub(crate) scale_factor: f32,
+    pub(crate) is_emoji: bool,
+}
+
+impl Eq for RenderGlyphParams {}
+
+impl Hash for RenderGlyphParams {
+    fn hash<H: Hasher>(&self, state: &mut H) {
+        self.font_id.0.hash(state);
+        self.glyph_id.0.hash(state);
+        self.font_size.0.to_bits().hash(state);
+        self.subpixel_variant.hash(state);
+        self.scale_factor.to_bits().hash(state);
+    }
+}
+
+#[derive(Clone, Debug, PartialEq)]
+pub struct RenderEmojiParams {
+    pub(crate) font_id: FontId,
+    pub(crate) glyph_id: GlyphId,
+    pub(crate) font_size: Pixels,
+    pub(crate) scale_factor: f32,
+}
+
+impl Eq for RenderEmojiParams {}
+
+impl Hash for RenderEmojiParams {
+    fn hash<H: Hasher>(&self, state: &mut H) {
+        self.font_id.0.hash(state);
+        self.glyph_id.0.hash(state);
+        self.font_size.0.to_bits().hash(state);
+        self.scale_factor.to_bits().hash(state);
+    }
+}
+
+#[derive(Clone, Debug, Eq, PartialEq, Hash)]
+pub struct Font {
+    pub family: SharedString,
+    pub features: FontFeatures,
+    pub weight: FontWeight,
+    pub style: FontStyle,
+}
+
+pub fn font(family: impl Into<SharedString>) -> Font {
+    Font {
+        family: family.into(),
+        features: FontFeatures::default(),
+        weight: FontWeight::default(),
+        style: FontStyle::default(),
+    }
+}
+
+impl Font {
+    pub fn bold(mut self) -> Self {
+        self.weight = FontWeight::BOLD;
+        self
+    }
+}
+
+/// A struct for storing font metrics.
+/// It is used to define the measurements of a typeface.
+#[derive(Clone, Copy, Debug)]
+pub struct FontMetrics {
+    /// The number of font units that make up the "em square",
+    /// a scalable grid for determining the size of a typeface.
+    pub(crate) units_per_em: u32,
+
+    /// The vertical distance from the baseline of the font to the top of the glyph covers.
+    pub(crate) ascent: f32,
+
+    /// The vertical distance from the baseline of the font to the bottom of the glyph covers.
+    pub(crate) descent: f32,
+
+    /// The recommended additional space to add between lines of type.
+    pub(crate) line_gap: f32,
+
+    /// The suggested position of the underline.
+    pub(crate) underline_position: f32,
+
+    /// The suggested thickness of the underline.
+    pub(crate) underline_thickness: f32,
+
+    /// The height of a capital letter measured from the baseline of the font.
+    pub(crate) cap_height: f32,
+
+    /// The height of a lowercase x.
+    pub(crate) x_height: f32,
+
+    /// The outer limits of the area that the font covers.
+    pub(crate) bounding_box: Bounds<f32>,
+}
+
+impl FontMetrics {
+    /// Returns the vertical distance from the baseline of the font to the top of the glyph covers in pixels.
+    pub fn ascent(&self, font_size: Pixels) -> Pixels {
+        Pixels((self.ascent / self.units_per_em as f32) * font_size.0)
+    }
+
+    /// Returns the vertical distance from the baseline of the font to the bottom of the glyph covers in pixels.
+    pub fn descent(&self, font_size: Pixels) -> Pixels {
+        Pixels((self.descent / self.units_per_em as f32) * font_size.0)
+    }
+
+    /// Returns the recommended additional space to add between lines of type in pixels.
+    pub fn line_gap(&self, font_size: Pixels) -> Pixels {
+        Pixels((self.line_gap / self.units_per_em as f32) * font_size.0)
+    }
+
+    /// Returns the suggested position of the underline in pixels.
+    pub fn underline_position(&self, font_size: Pixels) -> Pixels {
+        Pixels((self.underline_position / self.units_per_em as f32) * font_size.0)
+    }
+
+    /// Returns the suggested thickness of the underline in pixels.
+    pub fn underline_thickness(&self, font_size: Pixels) -> Pixels {
+        Pixels((self.underline_thickness / self.units_per_em as f32) * font_size.0)
+    }
+
+    /// Returns the height of a capital letter measured from the baseline of the font in pixels.
+    pub fn cap_height(&self, font_size: Pixels) -> Pixels {
+        Pixels((self.cap_height / self.units_per_em as f32) * font_size.0)
+    }
+
+    /// Returns the height of a lowercase x in pixels.
+    pub fn x_height(&self, font_size: Pixels) -> Pixels {
+        Pixels((self.x_height / self.units_per_em as f32) * font_size.0)
+    }
+
+    /// Returns the outer limits of the area that the font covers in pixels.
+    pub fn bounding_box(&self, font_size: Pixels) -> Bounds<Pixels> {
+        (self.bounding_box / self.units_per_em as f32 * font_size.0).map(px)
+    }
+}