Code at the speed of thought – Zed is a high-performance, multiplayer code editor from the creators of Atom and Tree-sitter.
gpui: Keep Unicode separators on one line on Windows (#66159)
Lukas Wirth979cd3fdf02f
diff --git a/crates/gpui_windows/src/direct_write.rs b/crates/gpui_windows/src/direct_write.rsindex 304dc38663b..018b7e73464 100644--- a/crates/gpui_windows/src/direct_write.rs+++ b/crates/gpui_windows/src/direct_write.rs@@ -8,6 +8,7 @@ use anyhow::{Context, Result};use collections::HashMap;use gpui_util::{ResultExt, maybe};use parking_lot::{RwLock, RwLockUpgradableReadGuard};+use smallvec::SmallVec;use windows::{Win32::{Foundation::*,@@ -527,6 +528,73 @@ impl DirectWriteState {text: &str,font_size: Pixels,font_runs: &[FontRun],+ ) -> Result<LineLayout> {+ if !text.contains(is_line_separator) {+ return self.layout_line_without_separators(components, text, font_size, font_runs);+ }++ // DirectWrite honors mandatory breaks even without wrapping. Keep each+ // separator at a segment's end so no subsequent text moves to a new baseline.+ let mut layout = LineLayout {+ font_size,+ len: text.len(),+ ..Default::default()+ };+ let mut remaining_runs = font_runs;+ let mut run_offset = 0;+ let mut text_offset = 0;+ let mut segment_runs = SmallVec::<[FontRun; 4]>::new();+ for segment in text.split_inclusive(is_line_separator) {+ segment_runs.clear();+ let mut remaining_bytes = segment.len();+ while remaining_bytes > 0 {+ let Some(run) = remaining_runs.first() else {+ break;+ };+ let len = remaining_bytes.min(run.len - run_offset);+ if len > 0 {+ segment_runs.push(FontRun {+ len,+ font_id: run.font_id,+ });+ }+ remaining_bytes -= len;+ run_offset += len;+ if run_offset == run.len {+ remaining_runs = &remaining_runs[1..];+ run_offset = 0;+ }+ }++ let segment_layout =+ self.layout_line_without_separators(components, segment, font_size, &segment_runs)?;+ for mut run in segment_layout.runs {+ for glyph in &mut run.glyphs {+ glyph.index += text_offset;+ glyph.position.x += layout.width;+ }+ if let Some(last) = layout.runs.last_mut()+ && last.font_id == run.font_id+ {+ last.glyphs.append(&mut run.glyphs);+ } else {+ layout.runs.push(run);+ }+ }+ layout.width += segment_layout.width;+ layout.ascent = layout.ascent.max(segment_layout.ascent);+ layout.descent = layout.descent.max(segment_layout.descent);+ text_offset += segment.len();+ }+ Ok(layout)+ }++ fn layout_line_without_separators(+ &mut self,+ components: &DirectWriteComponents,+ text: &str,+ font_size: Pixels,+ font_runs: &[FontRun],) -> Result<LineLayout> {if font_runs.is_empty() {return Ok(LineLayout {@@ -1960,6 +2028,10 @@ fn is_color_glyph(const DEFAULT_LOCALE_NAME: PCWSTR = windows::core::w!("en-US");+fn is_line_separator(character: char) -> bool {+ matches!(character, '\u{2028}' | '\u{2029}')+}+#[cfg(test)]mod tests {use super::{DirectWriteState, DirectWriteTextSystem, GPUState, GlyphLayerTexture};@@ -1967,9 +2039,10 @@ mod tests {use crate::directx_devices::DirectXDevices;use anyhow::Result;use gpui::{- DevicePixels, Font, PlatformTextSystem, RenderGlyphParams, Rgba, bounds, point, px, size,+ DevicePixels, Font, FontWeight, PlatformTextSystem, RenderGlyphParams, Rgba, TextRun,+ TextSystem, WindowTextSystem, bounds, point, px, size,};- use std::ffi::c_void;+ use std::{ffi::c_void, sync::Arc};use windows::Win32::Graphics::Direct3D11::{D3D11_BIND_RENDER_TARGET, D3D11_RENDER_TARGET_VIEW_DESC, D3D11_RENDER_TARGET_VIEW_DESC_0,D3D11_RTV_DIMENSION_TEXTURE2D, D3D11_SUBRESOURCE_DATA, D3D11_TEX2D_RTV,@@ -1977,6 +2050,113 @@ mod tests {};use windows::Win32::Graphics::Dxgi::Common::{DXGI_FORMAT_B8G8R8A8_UNORM, DXGI_SAMPLE_DESC};+ #[test]+ fn unicode_line_separators_preserve_shaped_line_cursor() -> Result<()> {+ check_unicode_separator_cursor('\u{2028}')+ }++ #[test]+ fn unicode_paragraph_separators_preserve_shaped_line_cursor() -> Result<()> {+ check_unicode_separator_cursor('\u{2029}')+ }++ fn check_unicode_separator_cursor(separator: char) -> Result<()> {+ let platform_text_system = Arc::new(DirectWriteTextSystem::new(None)?);+ let font = Font {+ family: "Segoe UI".into(),+ ..Default::default()+ };+ platform_text_system.font_id(&font)?;+ let text_system = WindowTextSystem::new(Arc::new(TextSystem::new(platform_text_system)));++ let separated_letters = ["a", "b", "c", "d", "e", "f"].join(&separator.to_string());+ for text in [+ separated_letters,+ format!("{separator}ab{separator}{separator}cd{separator}"),+ format!("{separator}{separator}{separator}{separator}{separator}"),+ format!("é{separator}𐐀{separator}z"),+ ] {+ for multiple_fonts in [false, true] {+ let mut runs = vec![TextRun {+ len: text.len(),+ font: font.clone(),+ ..Default::default()+ }];+ if multiple_fonts {+ let first_len = text.chars().next().map_or(0, char::len_utf8);+ runs[0].len = first_len;+ let mut bold_font = font.clone();+ bold_font.weight = FontWeight::BOLD;+ runs.push(TextRun {+ len: text.len() - first_len,+ font: bold_font,+ ..Default::default()+ });+ }+ let shaped = text_system.shape_line(text.clone().into(), px(14.0), &runs, None);+ let mut reference_runs = runs.clone();+ let mut offset = 0;+ for run in &mut reference_runs {+ let end = offset + run.len;+ run.len = text[offset..end]+ .chars()+ .filter(|character| *character != separator)+ .map(char::len_utf8)+ .sum();+ offset = end;+ }+ let reference_text: String = text+ .chars()+ .filter(|character| *character != separator)+ .collect();+ let reference =+ text_system.shape_line(reference_text.into(), px(14.0), &reference_runs, None);+ assert!(+ (shaped.width - reference.width).abs() < px(0.001),+ "{text:?}, multiple_fonts={multiple_fonts}"+ );++ let visible_glyphs: Vec<_> = shaped+ .runs+ .iter()+ .flat_map(|run| run.glyphs.iter().map(|glyph| (run.font_id, glyph)))+ .filter(|(_, glyph)| !text[glyph.index..].starts_with(separator))+ .collect();+ let reference_glyphs: Vec<_> = reference+ .runs+ .iter()+ .flat_map(|run| run.glyphs.iter().map(|glyph| (run.font_id, glyph)))+ .collect();+ assert_eq!(visible_glyphs.len(), reference_glyphs.len(), "{text:?}");+ for ((actual_font, actual), (expected_font, expected)) in+ visible_glyphs.into_iter().zip(reference_glyphs)+ {+ assert_eq!(actual_font, expected_font, "{text:?}");+ assert_eq!(actual.id, expected.id, "{text:?}");+ assert!((actual.position.x - expected.position.x).abs() < px(0.001));+ assert!((actual.position.y - expected.position.y).abs() < px(0.001));+ let reference_index: usize = text[..actual.index]+ .chars()+ .filter(|character| *character != separator)+ .map(char::len_utf8)+ .sum();+ assert_eq!(reference_index, expected.index, "{text:?}");+ }++ let mut cursor = shaped.cursor();+ for (index, character) in text.char_indices() {+ let piece = cursor.take_until(index + character.len_utf8());+ assert_eq!(piece.text.as_ref(), character.to_string());+ assert_eq!(piece.len(), character.len_utf8());+ if character == separator {+ assert_eq!(piece.width, px(0.0));+ }+ }+ }+ }+ Ok(())+ }+#[test]fn test_cluster_map() {let cluster_map = [0];