feat: shape and antialias Tessera text with system fonts
Verify Tessera GUI / verify (push) Successful in 13m28s
Verify Tessera GUI / verify (push) Successful in 13m28s
This commit is contained in:
+7
-1
@@ -15,6 +15,7 @@
|
||||
| display_list.rs | Rendering primitives and color representation |
|
||||
| geometry.rs | Native points and rectangles |
|
||||
| software_renderer.rs | Software rasterization of the display list |
|
||||
| text.rs | Shared system font discovery, shaping, real measurements, antialiased glyphs and bounded caches |
|
||||
| README.md | Module map |
|
||||
|
||||
Aster is an unmodified source submodule. Language parsing, AST definitions,
|
||||
@@ -37,4 +38,9 @@ Tests in api.rs execute real HTTP CRUD and a controlled queued-PUT/DELETE race
|
||||
without opening a window. Tests in endor_host.rs cover lifecycle, direct script and
|
||||
module entry, page methods, multiline inputs, original source ranges, malformed input,
|
||||
entry checks, budgets, failure preservation and stale-result invalidation. They
|
||||
run only in remote CI. See the [project guide](../README.md) for public behavior.
|
||||
run only in remote CI. Font tests in text.rs and software_renderer.rs cover real
|
||||
advances, multiline height, fractional scaling, CJK fallback, grapheme-safe fitting,
|
||||
antialiasing and transparency. A process-wide mutex keeps font discovery, shaping
|
||||
and glyph caches shared between the worker's layout and window redraw. The
|
||||
256-string/512-KiB source cache and 4096-glyph/32-MiB image cache are discarded
|
||||
when their budgets are exceeded. See the [project guide](../README.md) for public behavior.
|
||||
|
||||
+4
-2
@@ -339,8 +339,10 @@ PUT waits for its worker result. Errors return 422 with diagnostics and preserve
|
||||
the last successful revision. A newer accepted PUT or DELETE supersedes older
|
||||
work (409); a full eight-entry queue returns 503. DELETE immediately clears the
|
||||
document. GET remains available while Aster executes. The window redraws from an
|
||||
owned snapshot; resize does not rerun Endor. This first stage builds static UI;
|
||||
events, persistent VM state, Chinese font rendering and process isolation remain
|
||||
owned snapshot; resize does not rerun Endor. Text uses system fonts, antialiasing
|
||||
and font fallback; Chinese needs an installed CJK font. Size 1 is 14 logical pixels
|
||||
with 20-pixel line height; larger sizes multiply both. This first stage builds static UI;
|
||||
events, persistent VM state and process isolation remain
|
||||
future work. It is not an untrusted-code sandbox.
|
||||
"##,
|
||||
name = namespace.name,
|
||||
|
||||
+14
-25
@@ -2,6 +2,7 @@ use crate::{
|
||||
display_list::{Color, DisplayList, DrawCommand},
|
||||
document::{CodeNode, RenderDocument},
|
||||
geometry::{Point, Rect},
|
||||
text::{self as typography, TextStyle},
|
||||
};
|
||||
|
||||
const PANEL: Color = Color::rgb(247, 247, 245);
|
||||
@@ -154,14 +155,13 @@ pub fn build(
|
||||
if state.selected_node_id.as_deref() == Some(node.id.as_str()) {
|
||||
fill(&mut list, row, 5.0 * scale, SELECTED);
|
||||
}
|
||||
text(
|
||||
&mut list,
|
||||
row.x + (9.0 + depth as f32 * 14.0) * scale,
|
||||
row.y + 8.0 * scale,
|
||||
&fit(&format!("{} {}", node.kind, node.name), 44),
|
||||
scale,
|
||||
TEXT,
|
||||
let text_x = row.x + (9.0 + depth as f32 * 14.0) * scale;
|
||||
let label = typography::fit(
|
||||
&format!("{} {}", node.kind, node.name),
|
||||
(width - 14.0 * scale - text_x).max(0.0),
|
||||
TextStyle::code().scaled(scale),
|
||||
);
|
||||
text(&mut list, text_x, row.y + 3.0 * scale, &label, scale, TEXT);
|
||||
layout.rows.push(TreeRowHit {
|
||||
rect: row,
|
||||
node_id: node.id.clone(),
|
||||
@@ -235,7 +235,7 @@ fn draw_source(
|
||||
let first_y = area.y + 42.0 * scale;
|
||||
let maximum_lines =
|
||||
((area.y + area.height - first_y - 10.0 * scale) / line_height).max(0.0) as usize;
|
||||
let max_chars = ((area.width / (8.0 * scale)) - 9.0).max(8.0) as usize;
|
||||
let source_width = (area.width - 65.0 * scale).max(0.0);
|
||||
|
||||
for (offset, source_line) in all_lines[start..end].iter().take(maximum_lines).enumerate() {
|
||||
let line_number = start + offset + 1;
|
||||
@@ -252,7 +252,11 @@ fn draw_source(
|
||||
list,
|
||||
area.x + 55.0 * scale,
|
||||
y,
|
||||
&fit(&source_line.replace('\t', " "), max_chars),
|
||||
&typography::fit(
|
||||
&source_line.replace('\t', " "),
|
||||
source_width,
|
||||
TextStyle::code().scaled(scale),
|
||||
),
|
||||
scale,
|
||||
TEXT,
|
||||
);
|
||||
@@ -266,21 +270,6 @@ fn flatten<'a>(node: &'a CodeNode, depth: usize, output: &mut Vec<(usize, &'a Co
|
||||
}
|
||||
}
|
||||
|
||||
fn fit(value: &str, maximum: usize) -> String {
|
||||
let characters: Vec<_> = value.chars().collect();
|
||||
if characters.len() <= maximum {
|
||||
return value.to_owned();
|
||||
}
|
||||
if maximum < 3 {
|
||||
return characters.into_iter().take(maximum).collect();
|
||||
}
|
||||
characters
|
||||
.into_iter()
|
||||
.take(maximum - 3)
|
||||
.chain(['.', '.', '.'])
|
||||
.collect()
|
||||
}
|
||||
|
||||
fn fill(list: &mut DisplayList, rect: Rect, radius: f32, color: Color) {
|
||||
list.push(DrawCommand::FillRoundedRect {
|
||||
rect,
|
||||
@@ -293,7 +282,7 @@ fn text(list: &mut DisplayList, x: f32, y: f32, value: &str, scale: f32, color:
|
||||
list.push(DrawCommand::Text {
|
||||
origin: Point::new(x, y),
|
||||
value: value.to_owned(),
|
||||
scale: scale.round().max(1.0) as u32,
|
||||
style: TextStyle::code().scaled(scale),
|
||||
color,
|
||||
});
|
||||
}
|
||||
|
||||
+2
-1
@@ -1,4 +1,5 @@
|
||||
use crate::geometry::{Point, Rect};
|
||||
use crate::text::TextStyle;
|
||||
|
||||
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
|
||||
pub struct Color {
|
||||
@@ -45,7 +46,7 @@ pub enum DrawCommand {
|
||||
Text {
|
||||
origin: Point,
|
||||
value: String,
|
||||
scale: u32,
|
||||
style: TextStyle,
|
||||
color: Color,
|
||||
},
|
||||
}
|
||||
|
||||
+1
-1
@@ -300,7 +300,7 @@ impl RenderCommand {
|
||||
} => DrawCommand::Text {
|
||||
origin: Point::new(x * scale, y * scale),
|
||||
value: value.clone(),
|
||||
scale: ((*size as f32 * scale).round() as u32).max(1),
|
||||
style: crate::text::TextStyle::ui(*size).scaled(scale),
|
||||
color: parse_color(color)?,
|
||||
},
|
||||
})
|
||||
|
||||
+6
-12
@@ -378,7 +378,7 @@ mod tests {
|
||||
matches!(&document.frame.commands[0], RenderCommand::Text { value, size: 2, x: 24.0, y: 24.0, .. } if value == "Hello Endor")
|
||||
);
|
||||
assert!(
|
||||
matches!(&document.frame.commands[1], RenderCommand::RoundedRect { x: 24.0, y: 52.0, width: 240.0, height: 80.0, radius: 12.0, color } if color == "#DCE8FF")
|
||||
matches!(&document.frame.commands[1], RenderCommand::RoundedRect { x: 24.0, y: 76.0, width: 240.0, height: 80.0, radius: 12.0, color } if color == "#DCE8FF")
|
||||
);
|
||||
assert_eq!(document.display_list(2.0).unwrap().commands().len(), 3);
|
||||
let wrapped = compile(include_str!("../examples/main.endor"), "app.main", 10).unwrap();
|
||||
@@ -553,19 +553,16 @@ paint(ui.text("last"))"#;
|
||||
&document.frame.commands[1],
|
||||
RenderCommand::RoundedRect {
|
||||
x: 24.0,
|
||||
y: 52.0,
|
||||
y: 76.0,
|
||||
width: 240.0,
|
||||
height: 80.0,
|
||||
..
|
||||
}
|
||||
));
|
||||
let first_width = crate::text::measure("Aster VM", crate::text::TextStyle::ui(1)).width;
|
||||
assert!(matches!(
|
||||
&document.frame.commands[3],
|
||||
RenderCommand::Text {
|
||||
x: 120.0,
|
||||
y: 144.0,
|
||||
..
|
||||
}
|
||||
RenderCommand::Text { x, y: 168.0, .. } if (*x - (24.0 + first_width + 12.0 + 8.0 + 12.0)).abs() < 0.01
|
||||
));
|
||||
// Candidate::close already proved zero remaining VM objects. Both
|
||||
// redraws must still work from native data at different display scales.
|
||||
@@ -583,13 +580,10 @@ function main(): View { let child = ui.text("shared") return wrap(child) }"#;
|
||||
&document.frame.commands[0],
|
||||
RenderCommand::Text { x: 4.0, y: 4.0, .. }
|
||||
));
|
||||
let width = crate::text::measure("shared", crate::text::TextStyle::ui(1)).width;
|
||||
assert!(matches!(
|
||||
&document.frame.commands[1],
|
||||
RenderCommand::Text {
|
||||
x: 60.0,
|
||||
y: 4.0,
|
||||
..
|
||||
}
|
||||
RenderCommand::Text { x, y: 4.0, .. } if (*x - (4.0 + width + 8.0)).abs() < 0.01
|
||||
));
|
||||
}
|
||||
|
||||
|
||||
+4
-2
@@ -3,6 +3,7 @@ use anyhow::{Result, bail};
|
||||
|
||||
use crate::{
|
||||
document::{Frame, RenderCommand},
|
||||
text::{self, TextStyle},
|
||||
ui_bridge::{MAX_DIMENSION, UiKind, UiNode},
|
||||
};
|
||||
|
||||
@@ -50,9 +51,10 @@ fn layout(
|
||||
size: *size,
|
||||
color: color.clone(),
|
||||
});
|
||||
let measured = text::measure(value, TextStyle::ui(*size));
|
||||
Size {
|
||||
width: value.chars().count() as f32 * 8.0 * *size as f32,
|
||||
height: 8.0 * *size as f32,
|
||||
width: measured.width,
|
||||
height: measured.height,
|
||||
}
|
||||
}
|
||||
UiKind::Rect {
|
||||
|
||||
@@ -9,6 +9,7 @@ mod geometry;
|
||||
mod layout;
|
||||
mod scene;
|
||||
mod software_renderer;
|
||||
mod text;
|
||||
mod ui_bridge;
|
||||
|
||||
use std::sync::{Arc, RwLock};
|
||||
|
||||
+37
-35
@@ -1,8 +1,7 @@
|
||||
use font8x8::{BASIC_FONTS, UnicodeFonts};
|
||||
|
||||
use crate::{
|
||||
display_list::{Color, DisplayList, DrawCommand},
|
||||
geometry::{Point, Rect},
|
||||
text::{self, TextStyle},
|
||||
};
|
||||
|
||||
pub struct SoftwareRenderer;
|
||||
@@ -32,9 +31,9 @@ impl SoftwareRenderer {
|
||||
DrawCommand::Text {
|
||||
origin,
|
||||
value,
|
||||
scale,
|
||||
style,
|
||||
color,
|
||||
} => canvas.draw_text(*origin, value, *scale, *color),
|
||||
} => canvas.draw_text(*origin, value, *style, *color),
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -88,29 +87,12 @@ impl Canvas<'_> {
|
||||
}
|
||||
}
|
||||
|
||||
fn draw_text(&mut self, origin: Point, value: &str, scale: u32, color: Color) {
|
||||
let scale = scale.max(1) as i32;
|
||||
let mut cursor_x = origin.x.round() as i32;
|
||||
let baseline_y = origin.y.round() as i32;
|
||||
|
||||
for character in value.chars() {
|
||||
if let Some(glyph) = BASIC_FONTS.get(character) {
|
||||
for (row, byte) in glyph.iter().enumerate() {
|
||||
for column in 0..8 {
|
||||
if byte & (1 << column) != 0 {
|
||||
self.fill_pixels(
|
||||
cursor_x + column * scale,
|
||||
baseline_y + row as i32 * scale,
|
||||
scale,
|
||||
scale,
|
||||
color,
|
||||
);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
cursor_x += 8 * scale;
|
||||
}
|
||||
fn draw_text(&mut self, origin: Point, value: &str, style: TextStyle, color: Color) {
|
||||
let x = origin.x.round() as i32;
|
||||
let y = origin.y.round() as i32;
|
||||
text::draw(value, style, color, |dx, dy, pixel| {
|
||||
self.blend_pixel(x + dx, y + dy, pixel)
|
||||
});
|
||||
}
|
||||
|
||||
fn clamped_bounds(&self, rect: Rect) -> (i32, i32, i32, i32) {
|
||||
@@ -122,14 +104,6 @@ impl Canvas<'_> {
|
||||
)
|
||||
}
|
||||
|
||||
fn fill_pixels(&mut self, x: i32, y: i32, width: i32, height: i32, color: Color) {
|
||||
for py in y.max(0)..(y + height).min(self.height as i32) {
|
||||
for px in x.max(0)..(x + width).min(self.width as i32) {
|
||||
self.blend_pixel(px, py, color);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fn blend_pixel(&mut self, x: i32, y: i32, source: Color) {
|
||||
if x < 0 || y < 0 || x >= self.width as i32 || y >= self.height as i32 || source.alpha == 0
|
||||
{
|
||||
@@ -192,4 +166,32 @@ mod tests {
|
||||
assert_eq!(pixels[5], 0x00ff0000);
|
||||
assert_eq!(pixels[0], 0);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn text_edges_are_antialiased_and_respect_opacity() {
|
||||
let mut list = DisplayList::default();
|
||||
list.push(DrawCommand::Clear(Color::rgb(0, 0, 0)));
|
||||
list.push(DrawCommand::Text {
|
||||
origin: Point::new(2.0, 2.0),
|
||||
value: "Hello 中文".into(),
|
||||
style: TextStyle::ui(1).scaled(1.25),
|
||||
color: Color::rgba(255, 255, 255, 128),
|
||||
});
|
||||
let mut pixels = vec![0; 256 * 48];
|
||||
SoftwareRenderer::render(&list, &mut pixels, 256, 48);
|
||||
assert!(pixels.iter().any(|pixel| *pixel > 0));
|
||||
assert!(pixels.iter().all(|pixel| (pixel & 255) <= 128));
|
||||
assert!(pixels.iter().any(|pixel| (1..128).contains(&(pixel & 255))));
|
||||
|
||||
let mut invisible = DisplayList::default();
|
||||
invisible.push(DrawCommand::Text {
|
||||
origin: Point::new(2.0, 2.0),
|
||||
value: "Hello 中文".into(),
|
||||
style: TextStyle::ui(1),
|
||||
color: Color::rgba(255, 255, 255, 0),
|
||||
});
|
||||
let mut pixels = vec![0; 256 * 48];
|
||||
SoftwareRenderer::render(&invisible, &mut pixels, 256, 48);
|
||||
assert!(pixels.iter().all(|pixel| *pixel == 0));
|
||||
}
|
||||
}
|
||||
|
||||
+310
@@ -0,0 +1,310 @@
|
||||
//! Shared font discovery, shaping, measurement and antialiased rasterization.
|
||||
use std::{
|
||||
collections::HashMap,
|
||||
sync::{Mutex, OnceLock},
|
||||
};
|
||||
|
||||
use cosmic_text::{Align, Attrs, Buffer, Family, FontSystem, Metrics, Shaping, SwashCache, Wrap};
|
||||
|
||||
use crate::display_list::Color;
|
||||
|
||||
#[derive(Clone, Copy, Debug, Hash, PartialEq, Eq)]
|
||||
pub enum TextFamily {
|
||||
Interface,
|
||||
Code,
|
||||
}
|
||||
|
||||
#[derive(Clone, Copy, Debug)]
|
||||
pub struct TextStyle {
|
||||
pub font_size: f32,
|
||||
pub line_height: f32,
|
||||
pub family: TextFamily,
|
||||
}
|
||||
|
||||
impl TextStyle {
|
||||
pub fn ui(size: u32) -> Self {
|
||||
Self {
|
||||
font_size: 14.0 * size as f32,
|
||||
line_height: 20.0 * size as f32,
|
||||
family: TextFamily::Interface,
|
||||
}
|
||||
}
|
||||
|
||||
pub fn code() -> Self {
|
||||
Self {
|
||||
font_size: 13.0,
|
||||
line_height: 18.0,
|
||||
family: TextFamily::Code,
|
||||
}
|
||||
}
|
||||
|
||||
pub fn scaled(self, scale: f32) -> Self {
|
||||
Self {
|
||||
font_size: self.font_size * scale,
|
||||
line_height: self.line_height * scale,
|
||||
..self
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Clone, Copy, Debug)]
|
||||
pub struct TextSize {
|
||||
pub width: f32,
|
||||
pub height: f32,
|
||||
}
|
||||
|
||||
#[derive(Clone, Hash, PartialEq, Eq)]
|
||||
struct TextKey {
|
||||
value: String,
|
||||
font_size: u32,
|
||||
line_height: u32,
|
||||
family: TextFamily,
|
||||
}
|
||||
|
||||
struct PreparedText {
|
||||
buffer: Buffer,
|
||||
size: TextSize,
|
||||
}
|
||||
|
||||
struct TextEngine {
|
||||
fonts: FontSystem,
|
||||
swash: SwashCache,
|
||||
buffers: HashMap<TextKey, PreparedText>,
|
||||
source_bytes: usize,
|
||||
}
|
||||
|
||||
impl TextEngine {
|
||||
fn new() -> Self {
|
||||
let mut fonts = FontSystem::new();
|
||||
// Select installed, readable families rather than assuming an OS font
|
||||
// name exists. COSMIC Text handles per-glyph fallback (including CJK).
|
||||
let choose = |choices: &[&str]| {
|
||||
choices.iter().find_map(|choice| {
|
||||
fonts
|
||||
.db()
|
||||
.faces()
|
||||
.any(|face| face.families.iter().any(|(name, _)| name == choice))
|
||||
.then(|| (*choice).to_owned())
|
||||
})
|
||||
};
|
||||
let sans = choose(&[
|
||||
".AppleSystemUIFont",
|
||||
"SF Pro Text",
|
||||
"Helvetica Neue",
|
||||
"Segoe UI",
|
||||
"Noto Sans",
|
||||
"DejaVu Sans",
|
||||
"Liberation Sans",
|
||||
]);
|
||||
let mono = choose(&["Menlo", "Consolas", "DejaVu Sans Mono", "Liberation Mono"]);
|
||||
if let Some(name) = sans {
|
||||
fonts.db_mut().set_sans_serif_family(name);
|
||||
}
|
||||
if let Some(name) = mono {
|
||||
fonts.db_mut().set_monospace_family(name);
|
||||
}
|
||||
Self {
|
||||
fonts,
|
||||
swash: SwashCache::new(),
|
||||
buffers: HashMap::new(),
|
||||
source_bytes: 0,
|
||||
}
|
||||
}
|
||||
|
||||
fn prepare(&mut self, value: &str, style: TextStyle) -> TextKey {
|
||||
let key = TextKey {
|
||||
value: value.to_owned(),
|
||||
font_size: style.font_size.to_bits(),
|
||||
line_height: style.line_height.to_bits(),
|
||||
family: style.family,
|
||||
};
|
||||
if self.buffers.contains_key(&key) {
|
||||
return key;
|
||||
}
|
||||
// Cache recent shaped strings, without retaining every submitted source.
|
||||
if self.buffers.len() >= 256 || self.source_bytes + value.len() > 524_288 {
|
||||
self.buffers.clear();
|
||||
self.source_bytes = 0;
|
||||
}
|
||||
let family = match style.family {
|
||||
TextFamily::Interface => Family::SansSerif,
|
||||
TextFamily::Code => Family::Monospace,
|
||||
};
|
||||
let mut buffer = Buffer::new(
|
||||
&mut self.fonts,
|
||||
Metrics::new(style.font_size, style.line_height),
|
||||
);
|
||||
buffer.set_wrap(Wrap::None);
|
||||
buffer.set_size(None, None);
|
||||
buffer.set_text(
|
||||
value,
|
||||
&Attrs::new().family(family),
|
||||
Shaping::Advanced,
|
||||
Some(Align::Left),
|
||||
);
|
||||
buffer.shape_until_scroll(&mut self.fonts, false);
|
||||
let mut size = TextSize {
|
||||
width: 0.0,
|
||||
height: style.line_height,
|
||||
};
|
||||
for run in buffer.layout_runs() {
|
||||
size.width = size.width.max(run.line_w);
|
||||
size.height = size.height.max(run.line_top + run.line_height);
|
||||
}
|
||||
self.source_bytes += value.len();
|
||||
self.buffers
|
||||
.insert(key.clone(), PreparedText { buffer, size });
|
||||
key
|
||||
}
|
||||
}
|
||||
|
||||
fn engine() -> &'static Mutex<TextEngine> {
|
||||
static ENGINE: OnceLock<Mutex<TextEngine>> = OnceLock::new();
|
||||
ENGINE.get_or_init(|| Mutex::new(TextEngine::new()))
|
||||
}
|
||||
|
||||
pub fn measure(value: &str, style: TextStyle) -> TextSize {
|
||||
let mut engine = engine().lock().expect("text engine lock");
|
||||
let key = engine.prepare(value, style);
|
||||
engine.buffers[&key].size
|
||||
}
|
||||
|
||||
/// Draw at the actual device font size; no scaling of an already rasterized bitmap.
|
||||
pub fn draw(value: &str, style: TextStyle, color: Color, mut pixel: impl FnMut(i32, i32, Color)) {
|
||||
let mut engine = engine().lock().expect("text engine lock");
|
||||
let key = engine.prepare(value, style);
|
||||
let TextEngine {
|
||||
fonts,
|
||||
swash,
|
||||
buffers,
|
||||
..
|
||||
} = &mut *engine;
|
||||
let opacity = u16::from(color.alpha);
|
||||
buffers.get_mut(&key).expect("prepared text").buffer.draw(
|
||||
fonts,
|
||||
swash,
|
||||
cosmic_text::Color::rgb(color.red, color.green, color.blue),
|
||||
|x, y, width, height, color| {
|
||||
for dy in 0..height as i32 {
|
||||
for dx in 0..width as i32 {
|
||||
pixel(
|
||||
x + dx,
|
||||
y + dy,
|
||||
Color::rgba(
|
||||
color.r(),
|
||||
color.g(),
|
||||
color.b(),
|
||||
(u16::from(color.a()) * opacity / 255) as u8,
|
||||
),
|
||||
);
|
||||
}
|
||||
}
|
||||
},
|
||||
);
|
||||
// The cache is an optimization, never an archive of all submitted glyphs.
|
||||
if swash.image_cache.len() > 4096
|
||||
|| swash
|
||||
.image_cache
|
||||
.values()
|
||||
.flatten()
|
||||
.map(|image| image.data.len())
|
||||
.sum::<usize>()
|
||||
> 33_554_432
|
||||
{
|
||||
*swash = SwashCache::new();
|
||||
}
|
||||
}
|
||||
|
||||
/// Fit a single displayed source line without slicing a UTF-8/grapheme cluster.
|
||||
pub fn fit(value: &str, width: f32, style: TextStyle) -> String {
|
||||
use unicode_segmentation::UnicodeSegmentation;
|
||||
|
||||
// A source line may include a very large comment. Only shape a bounded
|
||||
// preview for the sidebar; the stored source and its AST spans stay intact.
|
||||
let truncated = value.len() > 8192;
|
||||
let value = if truncated {
|
||||
let end = value
|
||||
.grapheme_indices(true)
|
||||
.map(|(index, _)| index)
|
||||
.take_while(|index| *index <= 8192)
|
||||
.last()
|
||||
.unwrap_or(0);
|
||||
&value[..end]
|
||||
} else {
|
||||
value
|
||||
};
|
||||
if !truncated && measure(value, style).width <= width {
|
||||
return value.to_owned();
|
||||
}
|
||||
let ellipsis = "…";
|
||||
if width <= 0.0 || measure(ellipsis, style).width > width {
|
||||
return String::new();
|
||||
}
|
||||
let ends: Vec<_> = value
|
||||
.grapheme_indices(true)
|
||||
.map(|(start, part)| start + part.len())
|
||||
.collect();
|
||||
let mut low = 0;
|
||||
let mut high = ends.len();
|
||||
while low < high {
|
||||
let count = (low + high).div_ceil(2);
|
||||
let end = ends[count - 1];
|
||||
let candidate = format!("{}{ellipsis}", &value[..end]);
|
||||
if measure(&candidate, style).width <= width {
|
||||
low = count;
|
||||
} else {
|
||||
high = count - 1;
|
||||
}
|
||||
}
|
||||
let end = low.checked_sub(1).map_or(0, |index| ends[index]);
|
||||
format!("{}{ellipsis}", &value[..end])
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
use unicode_segmentation::UnicodeSegmentation;
|
||||
|
||||
#[test]
|
||||
fn proportional_metrics_monospace_and_multiline_height_come_from_the_fonts() {
|
||||
let ui = TextStyle::ui(1);
|
||||
assert!(measure("WWWW", ui).width > measure("iiii", ui).width * 2.0);
|
||||
let mono = TextStyle::code();
|
||||
assert!((measure("WWWW", mono).width - measure("iiii", mono).width).abs() < 0.1);
|
||||
assert_eq!(measure("one\ntwo", ui).height, ui.line_height * 2.0);
|
||||
let width = measure("Hello Endor", ui).width;
|
||||
assert!((measure("Hello Endor", ui.scaled(1.25)).width - width * 1.25).abs() < 0.5);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn system_fallback_shapes_chinese_without_missing_glyphs() {
|
||||
let mut engine = engine().lock().unwrap();
|
||||
for style in [TextStyle::ui(1), TextStyle::code()] {
|
||||
let key = engine.prepare("中文字体", style);
|
||||
let glyphs: Vec<_> = engine.buffers[&key]
|
||||
.buffer
|
||||
.layout_runs()
|
||||
.flat_map(|run| run.glyphs)
|
||||
.collect();
|
||||
assert_eq!(glyphs.len(), 4);
|
||||
assert!(glyphs.iter().all(|glyph| glyph.glyph_id != 0));
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn ellipsis_fits_actual_width_and_preserves_graphemes() {
|
||||
let style = TextStyle::code();
|
||||
let value = "e\u{301}e\u{301}中文字体e\u{301}e\u{301}";
|
||||
let width = measure("e\u{301}e\u{301}中…", style).width + 0.01;
|
||||
let fitted = fit(value, width, style);
|
||||
let prefix = fitted.strip_suffix('…').unwrap();
|
||||
assert!(value.starts_with(prefix));
|
||||
assert!(
|
||||
value
|
||||
.grapheme_indices(true)
|
||||
.any(|(index, _)| index == prefix.len())
|
||||
);
|
||||
assert!(measure(&fitted, style).width <= width);
|
||||
assert_eq!(fit(value, 0.0, style), "");
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user