mirrors/ghostty
1
0
Fork 0
mirror of https://github.com/ghostty-org/ghostty.git synced 2026-04-19 05:50:27 +00:00
Code Issues Packages Projects Releases Wiki Activity

font/shaper/coretext: Detect ligatures to avoid positioning (marking) glyphs incorrectly (#10295)

Browse Source 
This PR implements a heuristic for detecting ligatures that then
prevents resetting to the cell grid prematurely, avoiding position
errors from glyphs that follow ligatures. The inspiration for this was
the example from https://github.com/ghostty-org/ghostty/pull/10179 that
was off.

See the giant comment for an explanation of the heuristic.

The tests for this are the following:

### Tai Tham
The Tai Tham example from
https://github.com/ghostty-org/ghostty/pull/10179 got updated since now
the marking glyph is attached to the ligature cell correctly.

Browser:
ᩉ᩠ᨿᩩ

Before:
<img width="970" height="110" alt="CleanShot 2026-01-12 at 10 02 42@2x"
src="https://github.com/user-attachments/assets/1315bbeb-0541-420a-91a1-bac39897efe3"
/>

After:
<img width="962" height="122" alt="CleanShot 2026-01-12 at 10 02 57@2x"
src="https://github.com/user-attachments/assets/ca2b3e1d-0785-462f-993c-f482d875a1e9"
/>

### Javanese

Browser:
ꦤ꧀ꦲꦸ

Before:
<img width="962" height="98" alt="CleanShot 2026-01-12 at 10 05 43@2x"
src="https://github.com/user-attachments/assets/74002334-7140-4646-806e-2194457e56c5"
/>

After:
<img width="962" height="110" alt="CleanShot 2026-01-12 at 10 05 23@2x"
src="https://github.com/user-attachments/assets/49c08ac9-98af-409c-9b0e-49a34da93597"
/>

There does seem to be a small maybe single pixel difference here, and I
didn't investigate why.

### Chakma

Browser:
𑄝𑄖𑄳𑄠𑄬

Before:
<img width="1406" height="104" alt="CleanShot 2026-01-12 at 10 07 52@2x"
src="https://github.com/user-attachments/assets/3ba7a9d8-d2a2-4e47-976a-8c7702462a49"
/>

After:
<img width="1408" height="104" alt="CleanShot 2026-01-12 at 10 08 08@2x"
src="https://github.com/user-attachments/assets/c25c4a41-b651-4109-8ded-69983fc77267"
/>

### Bengali

Browser:
রাষ্ট্রে

Before:
<img width="1370" height="84" alt="CleanShot 2026-01-12 at 10 10 42@2x"
src="https://github.com/user-attachments/assets/c59e5fc9-0e9e-4c8f-b937-025ad28866d2"
/>

After:
<img width="1370" height="96" alt="CleanShot 2026-01-12 at 10 11 00@2x"
src="https://github.com/user-attachments/assets/d108dcda-b0b5-4824-b3e4-d1e2ddb6d6de"
/>

This one doesn't match the browser, but it seems like a CoreText or font
issue.

### Log output

I've got a `log.txt` with 15k lines from "cell_offset.cluster differs
from cluster (potential ligature detected)" logs when I run
[ttylang](https://github.com/jacobsandlund/ttylang) (printing the
Universal Declaration of Human Rights in various languages).

But right now when I try to create a gist with it, I get:

<img width="1554" height="584" alt="CleanShot 2026-01-12 at 10 15 29@2x"
src="https://github.com/user-attachments/assets/b8a5dd0c-c034-45f6-a2fb-80c67f93f26f"
/>
This commit is contained in:
Mitchell Hashimoto
2026-01-15 08:06:07 -08:00
committed by GitHub
parent 24b0ff05e2 54f1a6ce5e
commit 26e243a919
1 changed files with 379 additions and 60 deletions
Download Patch File Download Diff File Expand all files Collapse all files

439
src/font/shaper/coretext.zig
View File

@@ -6,6 +6,7 @@ const macos = @import("macos");
const font = @import("../main.zig");
const os = @import("../../os/main.zig");
const terminal = @import("../../terminal/main.zig");
const unicode = @import("../../unicode/main.zig");
const Feature = font.shape.Feature;
const FeatureList = font.shape.FeatureList;
const default_features = font.shape.default_features;
@@ -103,7 +104,7 @@ pub const Shaper = struct {
}
};
const CellOffset = struct {
const Offset = struct {
cluster: u32 = 0,
x: f64 = 0,
};
@@ -382,11 +383,12 @@ pub const Shaper = struct {
const line = typesetter.createLine(.{ .location = 0, .length = 0 });
self.cf_release_pool.appendAssumeCapacity(line);
// This keeps track of the current x offset (sum of advance.width)
var run_offset_x: f64 = 0.0;
// This keeps track of the current x offset (sum of advance.width) and
// the furthest cluster we've seen so far (max).
var run_offset: Offset = .{};
// This keeps track of the cell starting x and cluster.
var cell_offset: CellOffset = .{};
var cell_offset: Offset = .{};
// For debugging positions, turn this on:
//var run_offset_y: f64 = 0.0;
@@ -410,8 +412,8 @@ pub const Shaper = struct {
// other so we can iterate over them and just append to our
// cell buffer.
const runs = line.getGlyphRuns();
for (0..runs.getCount()) |i| {
const ctrun = runs.getValueAtIndex(macos.text.Run, i);
for (0..runs.getCount()) |run_i| {
const ctrun = runs.getValueAtIndex(macos.text.Run, run_i);
const status = ctrun.getStatus();
if (status.non_monotonic or status.right_to_left) non_ltr = true;
@@ -434,30 +436,75 @@ pub const Shaper = struct {
// Our cluster is also our cell X position. If the cluster changes
// then we need to reset our current cell offsets.
const cluster = state.codepoints.items[index].cluster;
if (cell_offset.cluster != cluster) pad: {
// We previously asserted this but for rtl text this is
// not true. So we check for this and break out. In the
// future we probably need to reverse pad for rtl but
// I don't have a solid test case for this yet so let's
// wait for that.
if (cell_offset.cluster > cluster) break :pad;
if (cell_offset.cluster != cluster) {
// We previously asserted that the new cluster is greater
// than cell_offset.cluster, but this isn't always true.
// See e.g. the "shape Chakma vowel sign with ligature
// (vowel sign renders first)" test.
cell_offset = .{
.cluster = cluster,
.x = run_offset_x,
const is_after_glyph_from_current_or_next_clusters =
cluster <= run_offset.cluster;
const is_first_codepoint_in_cluster = blk: {
var i = index;
while (i > 0) {
i -= 1;
const codepoint = state.codepoints.items[i];
// Skip surrogate pair padding
if (codepoint.codepoint == 0) continue;
break :blk codepoint.cluster != cluster;
} else break :blk true;
};
// For debugging positions, turn this on:
//cell_offset_y = run_offset_y;
// We need to reset the `cell_offset` at the start of a new
// cluster, but we do that conditionally if the codepoint
// `is_first_codepoint_in_cluster` and the cluster is not
// `is_after_glyph_from_current_or_next_clusters`, which is
// a heuristic to detect ligatures and avoid positioning
// glyphs that mark ligatures incorrectly. The idea is that
// if the first codepoint in a cluster doesn't appear in
// the stream, it's very likely that it combined with
// codepoints from a previous cluster into a ligature.
// Then, the subsequent codepoints are very likely marking
// glyphs that are placed relative to that ligature, so if
// we were to reset the `cell_offset` to align it with the
// grid, the positions would be off. The
// `!is_after_glyph_from_current_or_next_clusters` check is
// needed in case these marking glyphs come from a later
// cluster but are rendered first (see the Chakma and
// Bengali tests). In that case when we get to the
// codepoint that `is_first_codepoint_in_cluster`, but in a
// cluster that
// `is_after_glyph_from_current_or_next_clusters`, we don't
// want to reset to the grid and cause the positions to be
// off. (Note that we could go back and align the cells to
// the grid starting from the one from the cluster that
// rendered out of order, but that is more complicated so
// we don't do that for now. Also, it's TBD if there are
// exceptions to this heuristic for detecting ligatures,
// but using the logging below seems to show it works
// well.)
if (is_first_codepoint_in_cluster and
!is_after_glyph_from_current_or_next_clusters)
{
cell_offset = .{
.cluster = cluster,
.x = run_offset.x,
};
// For debugging positions, turn this on:
//cell_offset_y = run_offset_y;
}
}
// For debugging positions, turn this on:
//try self.debugPositions(alloc, run_offset_x, run_offset_y, cell_offset, cell_offset_y, position, index);
//try self.debugPositions(alloc, run_offset, run_offset_y, cell_offset, cell_offset_y, position, index);
const x_offset = position.x - cell_offset.x;
self.cell_buf.appendAssumeCapacity(.{
.x = @intCast(cluster),
.x = @intCast(cell_offset.cluster),
.x_offset = @intFromFloat(@round(x_offset)),
.y_offset = @intFromFloat(@round(position.y)),
.glyph_index = glyph,
@@ -465,7 +512,8 @@ pub const Shaper = struct {
// Add our advances to keep track of our run offsets.
// Advances apply to the NEXT cell.
run_offset_x += advance.width;
run_offset.x += advance.width;
run_offset.cluster = @max(run_offset.cluster, cluster);
// For debugging positions, turn this on:
//run_offset_y += advance.height;
@@ -641,31 +689,56 @@ pub const Shaper = struct {
fn debugPositions(
self: *Shaper,
alloc: Allocator,
run_offset_x: f64,
run_offset: Offset,
run_offset_y: f64,
cell_offset: CellOffset,
cell_offset: Offset,
cell_offset_y: f64,
position: macos.graphics.Point,
index: usize,
) !void {
const state = &self.run_state;
const x_offset = position.x - cell_offset.x;
const advance_x_offset = run_offset_x - cell_offset.x;
const advance_x_offset = run_offset.x - cell_offset.x;
const advance_y_offset = run_offset_y - cell_offset_y;
const x_offset_diff = x_offset - advance_x_offset;
const y_offset_diff = position.y - advance_y_offset;
const positions_differ = @abs(x_offset_diff) > 0.0001 or @abs(y_offset_diff) > 0.0001;
const old_offset_y = position.y - cell_offset_y;
const position_y_differs = @abs(cell_offset_y) > 0.0001;
const cluster = state.codepoints.items[index].cluster;
const cluster_differs = cluster != cell_offset.cluster;
if (positions_differ or position_y_differs) {
// To debug every loop, flip this to true:
const extra_debugging = false;
const is_previous_codepoint_prepend = if (cluster_differs or
extra_debugging)
blk: {
var i = index;
while (i > 0) {
i -= 1;
const codepoint = state.codepoints.items[i];
// Skip surrogate pair padding
if (codepoint.codepoint == 0) continue;
break :blk unicode.table.get(@intCast(codepoint.codepoint)).grapheme_boundary_class == .prepend;
}
break :blk false;
} else false;
const formatted_cps = if (positions_differ or
position_y_differs or
cluster_differs or
extra_debugging)
blk: {
var allocating = std.Io.Writer.Allocating.init(alloc);
const writer = &allocating.writer;
const codepoints = state.codepoints.items;
const current_cp = state.codepoints.items[index].codepoint;
var last_cluster: ?u32 = null;
for (codepoints) |cp| {
if ((cp.cluster == cell_offset.cluster or cp.cluster == cell_offset.cluster - 1 or cp.cluster == cell_offset.cluster + 1) and
for (codepoints, 0..) |cp, i| {
if ((@as(i32, @intCast(cp.cluster)) >= @as(i32, @intCast(cell_offset.cluster)) - 1 and
cp.cluster <= cluster + 1) and
cp.codepoint != 0 // Skip surrogate pair padding
) {
if (last_cluster) |last| {
@@ -673,49 +746,90 @@ pub const Shaper = struct {
try writer.writeAll(" ");
}
}
if (cp.cluster == cell_offset.cluster and cp.codepoint == current_cp) {
if (i == index) {
try writer.writeAll("▸");
}
try writer.print("\\u{{{x}}}", .{cp.codepoint});
// Using Python syntax for easier debugging
if (cp.codepoint > 0xFFFF) {
try writer.print("\\U{x:0>8}", .{cp.codepoint});
} else {
try writer.print("\\u{x:0>4}", .{cp.codepoint});
}
last_cluster = cp.cluster;
}
}
try writer.writeAll(" → ");
for (codepoints) |cp| {
if ((cp.cluster == cell_offset.cluster or cp.cluster == cell_offset.cluster - 1 or cp.cluster == cell_offset.cluster + 1) and
if ((@as(i32, @intCast(cp.cluster)) >= @as(i32, @intCast(cell_offset.cluster)) - 1 and
cp.cluster <= cluster + 1) and
cp.codepoint != 0 // Skip surrogate pair padding
) {
try writer.print("{u}", .{@as(u21, @intCast(cp.codepoint))});
}
}
const formatted_cps = try allocating.toOwnedSlice();
break :blk try allocating.toOwnedSlice();
} else "";
if (positions_differ) {
log.warn("position differs from advance: cluster={d} pos=({d:.2},{d:.2}) adv=({d:.2},{d:.2}) diff=({d:.2},{d:.2}) cps = {s}", .{
cell_offset.cluster,
x_offset,
position.y,
advance_x_offset,
advance_y_offset,
x_offset_diff,
y_offset_diff,
formatted_cps,
});
}
if (extra_debugging) {
log.warn("extra debugging of positions index={d} cell_offset.cluster={d} cluster={d} run_offset.cluster={d} diff={d} pos=({d:.2},{d:.2}) run_offset=({d:.2},{d:.2}) cell_offset=({d:.2},{d:.2}) is_prev_prepend={} cps = {s}", .{
index,
cell_offset.cluster,
cluster,
run_offset.cluster,
@as(isize, @intCast(cluster)) - @as(isize, @intCast(cell_offset.cluster)),
x_offset,
position.y,
run_offset.x,
run_offset_y,
cell_offset.x,
cell_offset_y,
is_previous_codepoint_prepend,
formatted_cps,
});
}
if (position_y_differs) {
log.warn("position.y differs from old offset.y: cluster={d} pos=({d:.2},{d:.2}) run_offset=({d:.2},{d:.2}) cell_offset=({d:.2},{d:.2}) old offset.y={d:.2} cps = {s}", .{
cell_offset.cluster,
x_offset,
position.y,
run_offset_x,
run_offset_y,
cell_offset.x,
cell_offset_y,
old_offset_y,
formatted_cps,
});
}
if (positions_differ) {
log.warn("position differs from advance: cluster={d} pos=({d:.2},{d:.2}) adv=({d:.2},{d:.2}) diff=({d:.2},{d:.2}) cps = {s}", .{
cluster,
x_offset,
position.y,
advance_x_offset,
advance_y_offset,
x_offset_diff,
y_offset_diff,
formatted_cps,
});
}
if (position_y_differs) {
log.warn("position.y differs from old offset.y: cluster={d} pos=({d:.2},{d:.2}) run_offset=({d:.2},{d:.2}) cell_offset=({d:.2},{d:.2}) old offset.y={d:.2} cps = {s}", .{
cluster,
x_offset,
position.y,
run_offset.x,
run_offset_y,
cell_offset.x,
cell_offset_y,
old_offset_y,
formatted_cps,
});
}
if (cluster_differs) {
log.warn("cell_offset.cluster differs from cluster (potential ligature detected) cell_offset.cluster={d} cluster={d} run_offset.cluster={d} diff={d} pos=({d:.2},{d:.2}) run_offset=({d:.2},{d:.2}) cell_offset=({d:.2},{d:.2}) is_prev_prepend={} cps = {s}", .{
cell_offset.cluster,
cluster,
run_offset.cluster,
@as(isize, @intCast(cluster)) - @as(isize, @intCast(cell_offset.cluster)),
x_offset,
position.y,
run_offset.x,
run_offset_y,
cell_offset.x,
cell_offset_y,
is_previous_codepoint_prepend,
formatted_cps,
});
}
}
};
@@ -1463,11 +1577,13 @@ test "shape Devanagari string" {
try testing.expect(run != null);
const cells = try shaper.shape(run.?);
// To understand the `x`/`cluster` assertions here, run with the "For
// debugging positions" code turned on and `extra_debugging` set to true.
try testing.expectEqual(@as(usize, 8), cells.len);
try testing.expectEqual(@as(u16, 0), cells[0].x);
try testing.expectEqual(@as(u16, 1), cells[1].x);
try testing.expectEqual(@as(u16, 2), cells[2].x);
try testing.expectEqual(@as(u16, 3), cells[3].x);
try testing.expectEqual(@as(u16, 4), cells[3].x);
try testing.expectEqual(@as(u16, 4), cells[4].x);
try testing.expectEqual(@as(u16, 5), cells[5].x);
try testing.expectEqual(@as(u16, 5), cells[6].x);
@@ -1584,7 +1700,7 @@ test "shape Tai Tham letters (position.y differs from advance)" {
try testing.expectEqual(@as(usize, 3), cells.len);
try testing.expectEqual(@as(u16, 0), cells[0].x);
try testing.expectEqual(@as(u16, 0), cells[1].x);
try testing.expectEqual(@as(u16, 1), cells[2].x); // U from second grapheme
try testing.expectEqual(@as(u16, 0), cells[2].x); // U from second grapheme
// The U glyph renders at a y below zero
try testing.expectEqual(@as(i16, -3), cells[2].y_offset);
@@ -1592,6 +1708,209 @@ test "shape Tai Tham letters (position.y differs from advance)" {
try testing.expectEqual(@as(usize, 1), count);
}
test "shape Javanese ligatures" {
const testing = std.testing;
const alloc = testing.allocator;
// We need a font that supports Javanese for this to work, if we can't find
// Noto Sans Javanese Regular, which is a system font on macOS, we just
// skip the test.
var testdata = testShaperWithDiscoveredFont(
alloc,
"Noto Sans Javanese",
) catch return error.SkipZigTest;
defer testdata.deinit();
var buf: [32]u8 = undefined;
var buf_idx: usize = 0;
// First grapheme cluster:
buf_idx += try std.unicode.utf8Encode(0xa9a4, buf[buf_idx..]); // NA
buf_idx += try std.unicode.utf8Encode(0xa9c0, buf[buf_idx..]); // PANGKON
// Second grapheme cluster, combining with the first in a ligature:
buf_idx += try std.unicode.utf8Encode(0xa9b2, buf[buf_idx..]); // HA
buf_idx += try std.unicode.utf8Encode(0xa9b8, buf[buf_idx..]); // Vowel sign SUKU
// Make a screen with some data
var t = try terminal.Terminal.init(alloc, .{ .cols = 30, .rows = 3 });
defer t.deinit(alloc);
// Enable grapheme clustering
t.modes.set(.grapheme_cluster, true);
var s = t.vtStream();
defer s.deinit();
try s.nextSlice(buf[0..buf_idx]);
var state: terminal.RenderState = .empty;
defer state.deinit(alloc);
try state.update(alloc, &t);
// Get our run iterator
var shaper = &testdata.shaper;
var it = shaper.runIterator(.{
.grid = testdata.grid,
.cells = state.row_data.get(0).cells.slice(),
});
var count: usize = 0;
while (try it.next(alloc)) |run| {
count += 1;
const cells = try shaper.shape(run);
const cell_width = run.grid.metrics.cell_width;
try testing.expectEqual(@as(usize, 3), cells.len);
try testing.expectEqual(@as(u16, 0), cells[0].x);
try testing.expectEqual(@as(u16, 0), cells[1].x);
try testing.expectEqual(@as(u16, 0), cells[2].x);
// The vowel sign SUKU renders with correct x_offset
try testing.expect(cells[2].x_offset > 3 * cell_width);
}
try testing.expectEqual(@as(usize, 1), count);
}
test "shape Chakma vowel sign with ligature (vowel sign renders first)" {
const testing = std.testing;
const alloc = testing.allocator;
// We need a font that supports Chakma for this to work, if we can't find
// Noto Sans Chakma Regular, which is a system font on macOS, we just skip
// the test.
var testdata = testShaperWithDiscoveredFont(
alloc,
"Noto Sans Chakma",
) catch return error.SkipZigTest;
defer testdata.deinit();
var buf: [32]u8 = undefined;
var buf_idx: usize = 0;
// First grapheme cluster:
buf_idx += try std.unicode.utf8Encode(0x1111d, buf[buf_idx..]); // BAA
// Second grapheme cluster:
buf_idx += try std.unicode.utf8Encode(0x11116, buf[buf_idx..]); // TAA
buf_idx += try std.unicode.utf8Encode(0x11133, buf[buf_idx..]); // Virama
// Third grapheme cluster, combining with the second in a ligature:
buf_idx += try std.unicode.utf8Encode(0x11120, buf[buf_idx..]); // YYAA
buf_idx += try std.unicode.utf8Encode(0x1112c, buf[buf_idx..]); // Vowel Sign U
// Make a screen with some data
var t = try terminal.Terminal.init(alloc, .{ .cols = 30, .rows = 3 });
defer t.deinit(alloc);
// Enable grapheme clustering
t.modes.set(.grapheme_cluster, true);
var s = t.vtStream();
defer s.deinit();
try s.nextSlice(buf[0..buf_idx]);
var state: terminal.RenderState = .empty;
defer state.deinit(alloc);
try state.update(alloc, &t);
// Get our run iterator
var shaper = &testdata.shaper;
var it = shaper.runIterator(.{
.grid = testdata.grid,
.cells = state.row_data.get(0).cells.slice(),
});
var count: usize = 0;
while (try it.next(alloc)) |run| {
count += 1;
const cells = try shaper.shape(run);
try testing.expectEqual(@as(usize, 4), cells.len);
try testing.expectEqual(@as(u16, 0), cells[0].x);
// See the giant "We need to reset the `cell_offset`" comment, but here
// we should technically have the rest of these be `x` of 1, but that
// would require going back in the stream to adjust past cells, and
// we don't take on that complexity.
try testing.expectEqual(@as(u16, 0), cells[1].x);
try testing.expectEqual(@as(u16, 0), cells[2].x);
try testing.expectEqual(@as(u16, 0), cells[3].x);
// The vowel sign U renders before the TAA:
try testing.expect(cells[1].x_offset < cells[2].x_offset);
}
try testing.expectEqual(@as(usize, 1), count);
}
test "shape Bengali ligatures with out of order vowels" {
const testing = std.testing;
const alloc = testing.allocator;
// We need a font that supports Bengali for this to work, if we can't find
// Arial Unicode MS, which is a system font on macOS, we just skip the
// test.
var testdata = testShaperWithDiscoveredFont(
alloc,
"Arial Unicode MS",
) catch return error.SkipZigTest;
defer testdata.deinit();
var buf: [32]u8 = undefined;
var buf_idx: usize = 0;
// First grapheme cluster:
buf_idx += try std.unicode.utf8Encode(0x09b0, buf[buf_idx..]); // RA
buf_idx += try std.unicode.utf8Encode(0x09be, buf[buf_idx..]); // Vowel sign AA
// Second grapheme cluster:
buf_idx += try std.unicode.utf8Encode(0x09b7, buf[buf_idx..]); // SSA
buf_idx += try std.unicode.utf8Encode(0x09cd, buf[buf_idx..]); // Virama
// Third grapheme cluster, combining with the second in a ligature:
buf_idx += try std.unicode.utf8Encode(0x099f, buf[buf_idx..]); // TTA
buf_idx += try std.unicode.utf8Encode(0x09cd, buf[buf_idx..]); // Virama
// Fourth grapheme cluster, combining with the previous two in a ligature:
buf_idx += try std.unicode.utf8Encode(0x09b0, buf[buf_idx..]); // RA
buf_idx += try std.unicode.utf8Encode(0x09c7, buf[buf_idx..]); // Vowel sign E
// Make a screen with some data
var t = try terminal.Terminal.init(alloc, .{ .cols = 30, .rows = 3 });
defer t.deinit(alloc);
// Enable grapheme clustering
t.modes.set(.grapheme_cluster, true);
var s = t.vtStream();
defer s.deinit();
try s.nextSlice(buf[0..buf_idx]);
var state: terminal.RenderState = .empty;
defer state.deinit(alloc);
try state.update(alloc, &t);
// Get our run iterator
var shaper = &testdata.shaper;
var it = shaper.runIterator(.{
.grid = testdata.grid,
.cells = state.row_data.get(0).cells.slice(),
});
var count: usize = 0;
while (try it.next(alloc)) |run| {
count += 1;
const cells = try shaper.shape(run);
try testing.expectEqual(@as(usize, 8), cells.len);
try testing.expectEqual(@as(u16, 0), cells[0].x);
try testing.expectEqual(@as(u16, 0), cells[1].x);
// See the giant "We need to reset the `cell_offset`" comment, but here
// we should technically have the rest of these be `x` of 1, but that
// would require going back in the stream to adjust past cells, and
// we don't take on that complexity.
try testing.expectEqual(@as(u16, 0), cells[2].x);
try testing.expectEqual(@as(u16, 0), cells[3].x);
try testing.expectEqual(@as(u16, 0), cells[4].x);
try testing.expectEqual(@as(u16, 0), cells[5].x);
try testing.expectEqual(@as(u16, 0), cells[6].x);
try testing.expectEqual(@as(u16, 0), cells[7].x);
// The vowel sign E renders before the SSA:
try testing.expect(cells[2].x_offset < cells[3].x_offset);
}
try testing.expectEqual(@as(usize, 1), count);
}
test "shape box glyphs" {
const testing = std.testing;
const alloc = testing.allocator;
@@ -2329,7 +2648,7 @@ fn testShaperWithDiscoveredFont(alloc: Allocator, font_req: [:0]const u8) !TestS
.monospace = false,
});
defer disco_it.deinit();
var face: font.DeferredFace = (try disco_it.next()).?;
var face: font.DeferredFace = (try disco_it.next()) orelse return error.FontNotFound;
errdefer face.deinit();
_ = try c.add(
alloc,