Files
RockerHXandFredApps ec12eba83e UI.1265: align CJK fallback text with the Latin baseline (#3081)
* UI.1265: align CJK fallback text with the Latin baseline

Use epaint's existing baseline alignment for system CJK fallback faces
and embedded faces tagged with CJK scripts. Mixed CJK, Latin and digits
then share a baseline in cells, editors and window titles.

Add regression coverage for zoom, font styles, wrapping, fixed-height
clipping, vertical alignment, editor height and title truncation.

Refs #1265, #2621.

* UI.1265: assert title baselines and document visual validation

* UI.1265: add baseline comparison and review validation

* UI.1265: adapt tooltip regression after upstream merge

The upstream shortcut update uses the runtime OS to choose tooltip text.
Use the harness OS for the existing split-button test expectation too.

Validation: cargo xtask ci; all 10 steps pass; 3,002 tests passed, 1 ignored, no exclusions.

* UI.1265: propagate CJK fallback to installed fonts

* UI.1265: align fallback baselines across cells

* UI.1265: align wrapped and unwrapped cell text

* UI.1265: preserve blank lines in wrapped cell alignment

* UI.1265: preserve centered fallback placement

* UI.1265: find CJK cell text by its visible bounds

Use the overlap of text ink, clip rect and cell rect to locate painted text
instead of testing a fixed offset from the galley origin. Baseline-aligned
fallbacks can move that origin above the cell on Ubuntu.

Keep the existing baseline and wrapping assertions unchanged.

Validation: cargo xtask ci on macOS; all 3 cjk_baseline tests on Ubuntu 24.04 x86_64.

---------

Co-authored-by: FredApps <153173854+FredApps@users.noreply.github.com>
2026-11-10 12:44:19 +01:00

473 lines
18 KiB
Rust

//! Overflowing text stays visible in its empty neighbours when its own cell is scrolled out (#1613).
use egui::{Rect, Shape};
use gridcraft_engine::Session;
use gridcraft_engine::core::CellRef;
use gridcraft_ui_egui::{SheetApp, grid::Geo};
use serde_json::json;
type Harness = egui_kittest::Harness<'static, SheetApp>;
const LEFT: &str = "This is a very long left-aligned text that overflows into many empty neighbouring cells";
const RIGHT: &str = "This is a very long right-aligned text that overflows into many empty neighbouring cells";
fn harness(setup: impl FnOnce(&mut Session)) -> Harness {
harness_with_size(egui::vec2(1200.0, 800.0), setup)
}
fn harness_with_size(size: egui::Vec2, setup: impl FnOnce(&mut Session)) -> Harness {
let mut s = Session::new();
s.new_workbook();
setup(&mut s);
s.execute("selection.set", json!({"range": "A20"})).unwrap();
let mut h = crate::common::builder().with_size(size).build_ui_state(
|ui, app: &mut SheetApp| {
app.logic(ui.ctx());
app.ui(ui);
},
crate::common::app(s),
);
h.run_steps(4);
h
}
/// Scroll so that `col` is the first column of the scrolled area.
fn scroll_to_col(h: &mut Harness, col: u32) {
let app = h.state_mut();
let sheet = app.session.active().unwrap().wb.active().unwrap();
let fc = sheet.freeze.map(|f| f.1).unwrap_or(0);
let x = (sheet.col_left(col) - sheet.col_left(fc)) as f32;
app.view_mut().unwrap().scroll.x = x;
h.run_steps(4);
}
/// Clip rects of the painted text shapes whose text is `text`.
fn text_clips(h: &Harness, text: &str) -> Vec<Rect> {
h.output()
.shapes
.iter()
.filter_map(|s| match &s.shape {
Shape::Text(t) if t.galley.job.text == text => Some(s.clip_rect),
_ => None,
})
.collect()
}
/// Painted extents of the text shapes whose text is `text`, cut to their clip rects.
fn text_visible_rects(h: &Harness, text: &str) -> Vec<Rect> {
h.output()
.shapes
.iter()
.filter_map(|s| match &s.shape {
Shape::Text(t) if t.galley.job.text == text => Some(t.visual_bounding_rect().intersect(s.clip_rect)),
_ => None,
})
.collect()
}
fn cell_rect(h: &Harness, cell: &str) -> Rect {
let app = h.state();
let sheet = app.session.active().unwrap().wb.active().unwrap();
let geo = Geo::new(sheet, app.grid.rect.unwrap(), app.view().scroll);
geo.cell_rect(sheet, CellRef::parse(cell).unwrap())
}
#[test]
fn overflow_text_stays_visible_when_source_cell_scrolls_out_left() {
let mut h = harness(|s| {
s.execute("cell.set", json!({"cell": "B1", "input": LEFT})).unwrap();
});
assert!(!text_clips(&h, LEFT).is_empty(), "B1 is drawn before scrolling");
scroll_to_col(&mut h, 2);
let c1 = cell_rect(&h, "C1");
let clips = text_clips(&h, LEFT);
assert!(clips.iter().any(|r| r.intersects(c1.shrink(1.0))), "B1's overflow is still drawn into C1 after scrolling: {clips:?}");
}
#[test]
fn right_aligned_overflow_stays_visible_when_source_cell_is_right_of_view() {
let mut h = harness(|s| {
s.execute("cell.set", json!({"cell": "Z1", "input": RIGHT})).unwrap();
s.execute("home.formatCells", json!({"range": "Z1", "style": {"align": {"h": "Right"}}})).unwrap();
});
// Scroll so that Z1 starts just past the right edge of the cell area.
{
let app = h.state_mut();
let sheet = app.session.active().unwrap().wb.active().unwrap();
let geo = Geo::new(sheet, app.grid.rect.unwrap(), app.view().scroll);
let x = sheet.col_left(25) as f32 - (geo.cells.width() - geo.frozen_w) / geo.z - 2.0;
app.view_mut().unwrap().scroll.x = x;
}
h.run_steps(4);
let (y1, z1, cells) = {
let app = h.state();
let sheet = app.session.active().unwrap().wb.active().unwrap();
let geo = Geo::new(sheet, app.grid.rect.unwrap(), app.view().scroll);
(geo.cell_rect(sheet, CellRef::parse("Y1").unwrap()), geo.cell_rect(sheet, CellRef::parse("Z1").unwrap()), geo.cells)
};
assert!(z1.left() >= cells.right(), "Z1 is out of view on the right ({z1:?} vs {cells:?})");
let visible = y1.intersect(cells).shrink(1.0);
let clips = text_clips(&h, RIGHT);
assert!(clips.iter().any(|r| r.intersects(visible)), "Z1's overflow is drawn into Y1: {clips:?} vs {visible:?}");
}
#[test]
fn scrolled_overflow_does_not_draw_over_frozen_columns() {
let mut h = harness(|s| {
s.execute("cell.set", json!({"cell": "C1", "input": LEFT})).unwrap();
s.execute("view.freezePanes", json!({"cell": "B2"})).unwrap();
});
scroll_to_col(&mut h, 4);
let a1 = cell_rect(&h, "A1");
let e1 = cell_rect(&h, "E1");
let clips = text_clips(&h, LEFT);
assert!(clips.iter().any(|r| r.intersects(e1.shrink(1.0))), "C1's overflow reaches E1: {clips:?}");
assert!(clips.iter().all(|r| !r.intersects(a1.shrink(1.0))), "C1's overflow stays out of frozen column A: {clips:?}");
}
/// Fully fitting wrapped lines retain the whole cell clip, including
/// room for glyphs extending below their logical line boxes.
#[test]
fn wrapped_text_fitting_lines_keep_full_cell_clip() {
const TEXT: &str = "Short wrapped text with two or three lines.";
let h = harness(|s| {
s.execute("home.columnWidth", json!({"cols": "B:B", "chars": 15})).unwrap();
s.execute("cell.set", json!({"cell": "B3", "input": TEXT})).unwrap();
s.execute("home.wrapText", json!({"range": "B3", "on": true})).unwrap();
s.execute("home.formatCells", json!({"range": "B3", "style": {"align": {"v": "Top"}}})).unwrap();
s.execute("home.rowHeight", json!({"rows": "3:3", "height": 120})).unwrap();
});
let cell = cell_rect(&h, "B3");
let shapes: Vec<_> = h
.output()
.shapes
.iter()
.filter_map(|shape| match &shape.shape {
Shape::Text(t) if t.galley.job.text == TEXT => Some((t, shape.clip_rect)),
_ => None,
})
.collect();
assert_eq!(shapes.len(), 1, "expected one wrapped text shape");
let (text, clip) = shapes[0];
assert!(text.galley.rows.len() >= 2, "text must wrap");
assert!(text.galley.size().y < cell.height(), "all lines must fit");
let last_bottom = text.pos.y + text.galley.rows.last().unwrap().rect().bottom();
assert!(last_bottom < cell.bottom() - 1.0, "room must remain below the final line");
assert!((clip.bottom() - cell.bottom()).abs() <= 0.5, "full cell clip must be retained: clip={clip:?}, cell={cell:?}");
}
/// Issue #2752: fixed-height wrapped cells must not paint
/// a fraction of a text line against the next row's border.
#[test]
fn wrapped_text_in_fixed_height_row_shows_only_complete_lines() {
const TEXT: &str = "Row 3 target. This is intentionally long text that must wrap \
across many lines within a narrow column. It must never \
paint over the next row.";
let h = harness(|s| {
s.execute("home.columnWidth", json!({"cols": "B:B", "chars": 12})).unwrap();
s.execute("cell.set", json!({"cell": "B3", "input": TEXT})).unwrap();
s.execute("home.wrapText", json!({"range": "B3", "on": true})).unwrap();
s.execute("home.formatCells", json!({"range": "B3", "style": {"align": {"v": "Top"}}})).unwrap();
// Apply the custom height after Wrap Text so AutoFit
// cannot expand the row for this scenario.
s.execute("home.rowHeight", json!({"rows": "3:3", "height": 62.67})).unwrap();
});
let cell = cell_rect(&h, "B3");
let shapes: Vec<_> = h
.output()
.shapes
.iter()
.filter_map(|shape| match &shape.shape {
Shape::Text(t) if t.galley.job.text == TEXT => Some((t, shape.clip_rect)),
_ => None,
})
.collect();
assert_eq!(shapes.len(), 1, "expected one painted wrapped text shape");
let (text, clip) = shapes[0];
assert!(text.galley.rows.len() > 4, "test must produce multiple wrapped lines");
assert!(text.galley.size().y > cell.height(), "wrapped text must exceed the fixed row height");
assert!(clip.top() >= cell.top() - 0.5 && clip.bottom() <= cell.bottom() + 0.5, "text clip must stay within B3: {clip:?} vs {cell:?}");
let mut full_rows_visible = 0;
for (index, row) in text.galley.rows.iter().enumerate() {
let top = text.pos.y + row.pos.y + row.visuals.mesh_bounds.top();
let bottom = text.pos.y + row.pos.y + row.visuals.mesh_bounds.bottom();
let full_height = bottom - top;
let visible_height = (bottom.min(clip.bottom()) - top.max(clip.top())).max(0.0);
let partly_visible = visible_height > 0.5 && visible_height < full_height - 0.5;
assert!(
!partly_visible,
"wrapped line {} is partially visible: \
line=[{top:.2}, {bottom:.2}], clip={clip:?}",
index + 1
);
if visible_height >= full_height - 0.5 {
full_rows_visible += 1;
}
}
assert!(full_rows_visible >= 2, "the clipping fix must still show complete text lines");
}
/// Issue #2752: a row shorter than a text line must not
/// render a fragment of wrapped text.
#[test]
fn wrapped_text_in_tiny_row_has_no_partial_lines() {
const TEXT: &str = "This wrapped text should not be partly painted.";
let h = harness(|s| {
s.execute("home.columnWidth", json!({"cols": "B:B", "chars": 12})).unwrap();
s.execute("cell.set", json!({"cell": "B3", "input": TEXT})).unwrap();
s.execute("home.wrapText", json!({"range": "B3", "on": true})).unwrap();
s.execute("home.formatCells", json!({"range": "B3", "style": {"align": {"v": "Top"}}})).unwrap();
s.execute("home.rowHeight", json!({"rows": "3:3", "height": 5})).unwrap();
});
let cell = cell_rect(&h, "B3");
let shapes: Vec<_> = h
.output()
.shapes
.iter()
.filter_map(|shape| match &shape.shape {
Shape::Text(t) if t.galley.job.text == TEXT => Some((t, shape.clip_rect)),
_ => None,
})
.collect();
assert_eq!(shapes.len(), 1, "expected the wrapped text shape");
let (text, clip) = shapes[0];
assert!(text.galley.rows.len() > 1, "text must wrap into multiple lines");
assert!(cell.height() < text.galley.rows[0].rect().height(), "test setup must produce a row shorter than one line");
assert!(clip.top() >= cell.top() - 0.5 && clip.bottom() <= cell.bottom() + 0.5, "text clip must remain inside its cell");
assert!(clip.height() <= 0.5, "no partial line should be visible: clip={clip:?}");
}
/// Issue #2752: the viewport bottom can cut through a line
/// that otherwise fits fully inside a wrapped cell.
#[test]
fn wrapped_text_clipping_survives_partial_vertical_scroll() {
let text = "Wrapped text must stay within both the worksheet cell \
and the viewport during vertical scrolling. "
.repeat(40);
let mut h = harness_with_size(egui::vec2(1200.0, 520.0), |s| {
s.execute("home.columnWidth", json!({"cols": "B:B", "chars": 12})).unwrap();
s.execute("cell.set", json!({"cell": "B3", "input": text})).unwrap();
s.execute("home.wrapText", json!({"range": "B3", "on": true})).unwrap();
s.execute("home.formatCells", json!({"range": "B3", "style": {"align": {"v": "Top"}}})).unwrap();
s.execute("home.rowHeight", json!({"rows": "3:3", "height": 350})).unwrap();
});
let initial_cell = cell_rect(&h, "B3");
let (target_center, zoom) = {
let app = h.state();
let sheet = app.session.active().unwrap().wb.active().unwrap();
let geo = Geo::new(sheet, app.grid.rect.unwrap(), app.view().scroll);
let shapes: Vec<_> = h
.output()
.shapes
.iter()
.filter_map(|shape| match &shape.shape {
Shape::Text(t) if t.galley.job.text == text => Some(t),
_ => None,
})
.collect();
assert_eq!(shapes.len(), 1, "expected wrapped B3 text");
let painted = shapes[0];
let center = painted
.galley
.rows
.iter()
.map(|row| {
let top = painted.pos.y + row.rect().top();
let bottom = painted.pos.y + row.rect().bottom();
(top, bottom)
})
.find(|(top, bottom)| {
let center = (top + bottom) / 2.0;
center > geo.cells.bottom() + 32.0 && *bottom < initial_cell.bottom() - 1.0
})
.map(|(top, bottom)| (top + bottom) / 2.0)
.expect("fixture must provide a cell-fitting line below the viewport");
(center, geo.z)
};
let viewport_bottom_before_scroll = {
let app = h.state();
let sheet = app.session.active().unwrap().wb.active().unwrap();
let geo = Geo::new(sheet, app.grid.rect.unwrap(), app.view().scroll);
geo.cells.bottom()
};
{
let app = h.state_mut();
app.view_mut().unwrap().scroll.y = (target_center - viewport_bottom_before_scroll) / zoom;
}
h.run_steps(4);
let cell = cell_rect(&h, "B3");
let (viewport, scroll_zoom) = {
let app = h.state();
let sheet = app.session.active().unwrap().wb.active().unwrap();
let geo = Geo::new(sheet, app.grid.rect.unwrap(), app.view().scroll);
(geo.cells, geo.z)
};
assert!(scroll_zoom > 0.0);
let shapes: Vec<_> = h
.output()
.shapes
.iter()
.filter_map(|shape| match &shape.shape {
Shape::Text(t) if t.galley.job.text == text => Some((t, shape.clip_rect)),
_ => None,
})
.collect();
assert_eq!(shapes.len(), 1, "B3 must remain painted");
let (painted, clip) = shapes[0];
assert!(clip.top() >= viewport.top() - 0.5, "clip exceeds viewport top: {clip:?} vs {viewport:?}");
assert!(clip.bottom() <= viewport.bottom() + 0.5, "clip exceeds viewport bottom: {clip:?} vs {viewport:?}");
assert!(clip.bottom() <= cell.bottom() + 0.5, "clip exceeds cell bottom: {clip:?} vs {cell:?}");
let full_line_bottoms: Vec<f32> =
painted.galley.rows.iter().map(|row| painted.pos.y + row.rect().bottom()).filter(|bottom| *bottom <= cell.bottom() + 0.01).collect();
let cell_line_bottom = full_line_bottoms.last().copied().expect("at least one line must fit within B3");
assert!(
painted.galley.rows.iter().any(|row| {
let top = painted.pos.y + row.rect().top();
let bottom = painted.pos.y + row.rect().bottom();
top + 0.5 < viewport.bottom() && viewport.bottom() < bottom - 0.5 && bottom <= cell.bottom() + 0.01
}),
"viewport bottom must cross a line that fits B3: \
viewport={viewport:?}, cell={cell:?}"
);
let expected_bottom = viewport.bottom().min(cell_line_bottom);
assert!(
(clip.bottom() - expected_bottom).abs() <= 0.5,
"clip must respect viewport and complete-line limits: \
clip={clip:?}, expected={expected_bottom:.2}"
);
}
/// Issue #2544: text in a frozen column keeps its whole cell while the other columns scroll.
#[test]
fn frozen_column_text_keeps_its_cell_when_scrolled() {
let mut h = harness(|s| {
s.execute("cell.set", json!({"cell": "A1", "input": LEFT})).unwrap();
s.execute("cell.set", json!({"cell": "C1", "input": "v"})).unwrap();
s.execute("view.freezeFirstColumn", json!({})).unwrap();
});
for col in [1, 2, 3, 8] {
scroll_to_col(&mut h, col);
let a1 = cell_rect(&h, "A1");
let clips = text_clips(&h, LEFT);
assert_eq!(clips.len(), 1, "A1 is drawn once: {clips:?}");
assert!(
(clips[0].left() - a1.left()).abs() <= 0.5 && (clips[0].right() - a1.right()).abs() <= 0.5,
"A1's text spans A1 at column {col}: {clips:?} vs {a1:?}"
);
let visible = text_visible_rects(&h, LEFT);
assert!(visible.len() == 1 && visible[0].is_positive(), "A1's text shows inside its clip at column {col}: {visible:?}");
}
}
/// Issue #2544: with two frozen columns, A1's text keeps overflowing across the whole of empty B1.
#[test]
fn frozen_text_overflows_to_the_freeze_line_when_scrolled() {
let mut h = harness(|s| {
s.execute("cell.set", json!({"cell": "A1", "input": LEFT})).unwrap();
s.execute("view.freezePanes", json!({"cell": "C1"})).unwrap();
});
for col in [2, 3, 4, 10] {
scroll_to_col(&mut h, col);
let (a1, b1) = (cell_rect(&h, "A1"), cell_rect(&h, "B1"));
let clips = text_clips(&h, LEFT);
assert_eq!(clips.len(), 1, "A1 is drawn once: {clips:?}");
assert!(
(clips[0].left() - a1.left()).abs() <= 0.5 && (clips[0].right() - b1.right()).abs() <= 0.5,
"A1's text spans A1:B1 at column {col}: {clips:?} vs {a1:?} {b1:?}"
);
}
}
/// Issue #2544: the frozen columns' gridlines reach the freeze line, and none is drawn inside
/// them at a scrolled column's edge.
#[test]
fn frozen_column_gridlines_stay_put_when_scrolled() {
let mut h = harness(|s| {
s.execute("view.freezePanes", json!({"cell": "C1"})).unwrap();
});
scroll_to_col(&mut h, 6);
let (a5, b5) = (cell_rect(&h, "A5"), cell_rect(&h, "B5"));
let frozen = |s: &egui::epaint::ClippedShape| s.clip_rect.right() <= b5.right() + 0.5 && s.clip_rect.left() <= a5.left();
let segments: Vec<[egui::Pos2; 2]> = h
.output()
.shapes
.iter()
.filter(|s| frozen(s))
.filter_map(|s| match &s.shape {
Shape::LineSegment { points, .. } => Some(*points),
_ => None,
})
.collect();
let row5 = segments.iter().find(|p| (p[0].y - (a5.top() - 0.5).round()).abs() <= 1.0 && p[0].y == p[1].y);
assert!(row5.is_some_and(|p| p[1].x >= b5.right() - 1.0), "row 5's gridline reaches the freeze line: {row5:?} vs {b5:?}");
let verticals: Vec<f32> = segments.iter().filter(|p| p[0].x == p[1].x && p[0].y < b5.bottom()).map(|p| p[0].x).collect();
let expected = [a5.left(), a5.right(), b5.right()].map(|x| x.round() - 0.5);
assert!(verticals.iter().all(|x| expected.iter().any(|e| (x - e).abs() <= 0.5)), "only A and B's edges: {verticals:?} vs {expected:?}");
}