Skip to content

armgit / zed

Public Imported from GitHub
0

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.rs
index 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];